/*
* var_expExpressionTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_expExpressionTable above.
*/
unsigned char *
var_expExpressionTable(struct variable *vp,
oid * name,
size_t *length,
int exact,
size_t *var_len, WriteMethod ** write_method)
{
struct expExpressionTable_data *StorageTmp = NULL;
DEBUGMSGTL(("expExpressionTable",
"var_expExpressionTable: Entering... \n"));
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(expExpressionTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL) {
if (vp->magic == EXPEXPRESSIONENTRYSTATUS)
*write_method = write_expExpressionEntryStatus;
return NULL;
}
switch (vp->magic) {
case EXPEXPRESSION:
*write_method = write_expExpression;
*var_len = StorageTmp->expExpressionLen;
return (u_char *) StorageTmp->expExpression;
case EXPEXPRESSIONVALUETYPE:
*write_method = write_expExpressionValueType;
*var_len = sizeof(StorageTmp->expExpressionValueType);
return (u_char *) & StorageTmp->expExpressionValueType;
case EXPEXPRESSIONCOMMENT:
*write_method = write_expExpressionComment;
*var_len = StorageTmp->expExpressionCommentLen;
return (u_char *) StorageTmp->expExpressionComment;
case EXPEXPRESSIONDELTALNTERVAL:
*write_method = write_expExpressionDeltaInterval;
*var_len = sizeof(StorageTmp->expExpressionDeltaInterval);
return (u_char *) & StorageTmp->expExpressionDeltaInterval;
case EXPEXPRESSIONPREFIX:
*var_len = StorageTmp->expExpressionPrefixLen * sizeof(oid);
return (u_char *) StorageTmp->expExpressionPrefix;
case EXPEXPRESSIONERRORS:
*var_len = sizeof(StorageTmp->expExpressionErrors);
return (u_char *) & StorageTmp->expExpressionErrors;
case EXPEXPRESSIONENTRYSTATUS:
*write_method = write_expExpressionEntryStatus;
*var_len = sizeof(StorageTmp->expExpressionEntryStatus);
return (u_char *) & StorageTmp->expExpressionEntryStatus;
default:
ERROR_MSG("");
}
return NULL;
}
int
write_expExpressionComment(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)
{
static char *tmpvar;
struct expExpressionTable_data *StorageTmp = NULL;
static size_t tmplen;
size_t newlen =
name_len -
(sizeof(expExpressionTable_variables_oid) / sizeof(oid) + 3 - 1);
DEBUGMSGTL(("expExpressionTable",
"write_expExpression entering action=%d... \n", action));
if ((StorageTmp =
header_complex(expExpressionTableStorage, NULL,
&name[sizeof(expExpressionTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL,
NULL)) == NULL)
return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
switch (action) {
case RESERVE1:
if (var_val_type != ASN_OCTET_STR) {
snmp_log(LOG_ERR,
"write to expExpressionComment not ASN_OCTET_STR\n");
return SNMP_ERR_WRONGTYPE;
}
if (StorageTmp->storageType != ST_NONVOLATILE)
return SNMP_ERR_NOTWRITABLE;
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
break;
case FREE:
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in string for
* you to use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in the UNDO case
*/
tmpvar = StorageTmp->expExpressionComment;
tmplen = StorageTmp->expExpressionCommentLen;
StorageTmp->expExpressionComment = netsnmp_memdup(var_val, var_val_len);
StorageTmp->expExpressionCommentLen = var_val_len;
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
SNMP_FREE(StorageTmp->expExpressionComment);
StorageTmp->expExpressionComment = tmpvar;
StorageTmp->expExpressionCommentLen = tmplen;
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
SNMP_FREE(tmpvar);
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
/*
* var_snmpNotifyFilterProfileTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_snmpNotifyFilterProfileTable above.
*/
unsigned char *
var_snmpNotifyFilterProfileTable(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len,
WriteMethod ** write_method)
{
struct snmpNotifyFilterProfileTable_data *StorageTmp = NULL;
int found = 1;
DEBUGMSGTL(("snmpNotifyFilterProfileTable",
"var_snmpNotifyFilterProfileTable: Entering... \n"));
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp = (struct snmpNotifyFilterProfileTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyFilterProfileTableStorage, vp, name,
length, exact, var_len, write_method)) == NULL) {
found = 0;
}
switch (vp->magic) {
case SNMPNOTIFYFILTERPROFILENAME:
*write_method = write_snmpNotifyFilterProfileName;
break;
case SNMPNOTIFYFILTERPROFILESTORTYPE:
*write_method = write_snmpNotifyFilterProfileStorType;
break;
case SNMPNOTIFYFILTERPROFILEROWSTATUS:
*write_method = write_snmpNotifyFilterProfileRowStatus;
break;
default:
*write_method = NULL;
}
if (!found) {
return NULL;
}
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case SNMPNOTIFYFILTERPROFILENAME:
*var_len = StorageTmp->snmpNotifyFilterProfileNameLen;
return (u_char *) StorageTmp->snmpNotifyFilterProfileName;
case SNMPNOTIFYFILTERPROFILESTORTYPE:
*var_len = sizeof(StorageTmp->snmpNotifyFilterProfileStorType);
return (u_char *) & StorageTmp->snmpNotifyFilterProfileStorType;
case SNMPNOTIFYFILTERPROFILEROWSTATUS:
*var_len = sizeof(StorageTmp->snmpNotifyFilterProfileRowStatus);
return (u_char *) & StorageTmp->snmpNotifyFilterProfileRowStatus;
default:
ERROR_MSG("");
}
return NULL;
}
int
write_snmpNotifyTag(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)
{
static char *tmpvar;
struct snmpNotifyTable_data *StorageTmp = NULL;
static size_t tmplen;
size_t newlen =
name_len - (sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
3 - 1);
DEBUGMSGTL(("snmpNotifyTable",
"write_snmpNotifyTag entering action=%d... \n", action));
if (action != RESERVE1 &&
(StorageTmp = (struct snmpNotifyTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyTableStorage, NULL,
&name[sizeof(snmpNotifyTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL,
NULL)) == NULL) {
if ((StorageTmp = StorageNew) == NULL)
return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
}
switch (action) {
case RESERVE1:
if (var_val_type != ASN_OCTET_STR) {
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > 255) {
return SNMP_ERR_WRONGLENGTH;
}
if (!snmpTagValid((char *) var_val, var_val_len)) {
return SNMP_ERR_WRONGVALUE;
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
tmpvar = StorageTmp->snmpNotifyTag;
tmplen = StorageTmp->snmpNotifyTagLen;
StorageTmp->snmpNotifyTag = (char*)calloc(1, var_val_len + 1);
if (NULL == StorageTmp->snmpNotifyTag)
return SNMP_ERR_RESOURCEUNAVAILABLE;
break;
case FREE:
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
memcpy(StorageTmp->snmpNotifyTag, var_val, var_val_len);
StorageTmp->snmpNotifyTagLen = var_val_len;
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
SNMP_FREE(StorageTmp->snmpNotifyTag);
StorageTmp->snmpNotifyTag = tmpvar;
StorageTmp->snmpNotifyTagLen = tmplen;
tmpvar = NULL;
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
SNMP_FREE(tmpvar);
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
/*
* var_expValueTable():
*/
unsigned char *
var_expValueTable(struct variable *vp,
oid * name,
size_t *length,
int exact, size_t *var_len, WriteMethod ** write_method)
{
static netsnmp_variable_list *vars;
size_t newlen =
*length - (sizeof(expValueTable_variables_oid) / sizeof(oid) +
3 - 1);
struct expValueTable_data *StorageTmp = NULL;
unsigned int counter32;
DEBUGMSGTL(("expValueTable", "var_expValueTable: Entering... \n"));
/*
* before we build valuetable we must free any other valutable if exist
*/
header_complex_free_all(expValueTableStorage, expValueTable_clean);
expValueTableStorage = NULL;
build_valuetable();
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(expValueTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL)
return NULL;
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
/*
* we only support counter32val
*/
case EXPVALUECOUNTER32VAL:
StorageTmp->expValueCounter32Val = Evaluate_Expression(StorageTmp);
*var_len = sizeof(StorageTmp->expValueCounter32Val);
return (u_char *) & StorageTmp->expValueCounter32Val;
case EXPVALUEUNSIGNED32VAL:
/* var_len = sizeof(StorageTmp->expValueUnsigned32Val); */
/* return (u_char *) & StorageTmp->expValueUnsigned32Val; */
return NULL;
case EXPVALUETIMETICKSVAL:
/* var_len = sizeof(StorageTmp->expValueTimeTicksVal); */
/* return (u_char *) & StorageTmp->expValueTimeTicksVal; */
return NULL;
case EXPVALUEINTEGER32VAL:
/* var_len = sizeof(StorageTmp->expValueInteger32Val); */
/* return (u_char *) & StorageTmp->expValueInteger32Val; */
return NULL;
case EXPVALUEIPADDRESSVAL:
/* var_len = sizeof(StorageTmp->expValueIpAddressVal); */
/* return (u_char *) & StorageTmp->expValueIpAddressVal; */
return NULL;
case EXPVALUEOCTETSTRINGVAL:
/* var_len = sizeof(StorageTmp->expValueOctetStringVal); */
/* return (u_char *) & StorageTmp->expValueOctetStringVal; */
return NULL;
case EXPVALUEOIDVAL:
/* var_len = StorageTmp->expValueOidValLen; */
/* return (u_char *) & StorageTmp->expValueOidVal; */
return NULL;
case EXPVALUECOUNTER64VAL:
/* var_len = sizeof(StorageTmp->expValueCounter64Val); */
/* return (u_char *) & StorageTmp->expValueCounter64Val; */
return NULL;
default:
ERROR_MSG("");
}
}
/*
* var_mteTriggerThresholdTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_mteTriggerThresholdTable above.
*/
unsigned char *
var_mteTriggerThresholdTable(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
struct mteTriggerTable_data *StorageTmp = NULL;
DEBUGMSGTL(("mteTriggerThresholdTable",
"var_mteTriggerThresholdTable: Entering... \n"));
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(mteTriggerTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL)
return NULL;
if (!(StorageTmp->mteTriggerTest[0] & MTETRIGGERTEST_THRESHOLD))
return NULL;
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case MTETRIGGERTHRESHOLDSTARTUP:
*write_method = write_mteTriggerThresholdStartup;
*var_len = sizeof(StorageTmp->mteTriggerThresholdStartup);
return (u_char *) & StorageTmp->mteTriggerThresholdStartup;
case MTETRIGGERTHRESHOLDRISING:
*write_method = write_mteTriggerThresholdRising;
*var_len = sizeof(StorageTmp->mteTriggerThresholdRising);
return (u_char *) & StorageTmp->mteTriggerThresholdRising;
case MTETRIGGERTHRESHOLDFALLING:
*write_method = write_mteTriggerThresholdFalling;
*var_len = sizeof(StorageTmp->mteTriggerThresholdFalling);
return (u_char *) & StorageTmp->mteTriggerThresholdFalling;
case MTETRIGGERTHRESHOLDDELTARISING:
*write_method = write_mteTriggerThresholdDeltaRising;
*var_len = sizeof(StorageTmp->mteTriggerThresholdDeltaRising);
return (u_char *) & StorageTmp->mteTriggerThresholdDeltaRising;
case MTETRIGGERTHRESHOLDDELTAFALLING:
*write_method = write_mteTriggerThresholdDeltaFalling;
*var_len = sizeof(StorageTmp->mteTriggerThresholdDeltaFalling);
return (u_char *) & StorageTmp->mteTriggerThresholdDeltaFalling;
case MTETRIGGERTHRESHOLDOBJECTSOWNER:
*write_method = write_mteTriggerThresholdObjectsOwner;
*var_len = StorageTmp->mteTriggerThresholdObjectsOwnerLen;
return (u_char *) StorageTmp->mteTriggerThresholdObjectsOwner;
case MTETRIGGERTHRESHOLDOBJECTS:
*write_method = write_mteTriggerThresholdObjects;
*var_len = StorageTmp->mteTriggerThresholdObjectsLen;
return (u_char *) StorageTmp->mteTriggerThresholdObjects;
case MTETRIGGERTHRESHOLDRISINGEVENTOWNER:
*write_method = write_mteTriggerThresholdRisingEventOwner;
*var_len = StorageTmp->mteTriggerThresholdRisingEventOwnerLen;
return (u_char *) StorageTmp->mteTriggerThresholdRisingEventOwner;
case MTETRIGGERTHRESHOLDRISINGEVENT:
*write_method = write_mteTriggerThresholdRisingEvent;
*var_len = StorageTmp->mteTriggerThresholdRisingEventLen;
return (u_char *) StorageTmp->mteTriggerThresholdRisingEvent;
case MTETRIGGERTHRESHOLDFALLINGEVENTOWNER:
*write_method = write_mteTriggerThresholdFallingEventOwner;
*var_len = StorageTmp->mteTriggerThresholdFallingEventOwnerLen;
return (u_char *) StorageTmp->mteTriggerThresholdFallingEventOwner;
case MTETRIGGERTHRESHOLDFALLINGEVENT:
*write_method = write_mteTriggerThresholdFallingEvent;
*var_len = StorageTmp->mteTriggerThresholdFallingEventLen;
return (u_char *) StorageTmp->mteTriggerThresholdFallingEvent;
case MTETRIGGERTHRESHOLDDELTARISINGEVENTOWNER:
*write_method = write_mteTriggerThresholdDeltaRisingEventOwner;
*var_len = StorageTmp->mteTriggerThresholdDeltaRisingEventOwnerLen;
return (u_char *) StorageTmp->
mteTriggerThresholdDeltaRisingEventOwner;
case MTETRIGGERTHRESHOLDDELTARISINGEVENT:
*write_method = write_mteTriggerThresholdDeltaRisingEvent;
*var_len = StorageTmp->mteTriggerThresholdDeltaRisingEventLen;
return (u_char *) StorageTmp->mteTriggerThresholdDeltaRisingEvent;
case MTETRIGGERTHRESHOLDDELTAFALLINGEVENTOWNER:
*write_method = write_mteTriggerThresholdDeltaFallingEventOwner;
*var_len =
StorageTmp->mteTriggerThresholdDeltaFallingEventOwnerLen;
return (u_char *) StorageTmp->
mteTriggerThresholdDeltaFallingEventOwner;
case MTETRIGGERTHRESHOLDDELTAFALLINGEVENT:
*write_method = write_mteTriggerThresholdDeltaFallingEvent;
*var_len = StorageTmp->mteTriggerThresholdDeltaFallingEventLen;
return (u_char *) StorageTmp->mteTriggerThresholdDeltaFallingEvent;
default:
ERROR_MSG("");
}
return NULL;
}
int
write_mteObjectsEntryStatus(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)
{
struct mteObjectsTable_data *StorageTmp = NULL;
static struct mteObjectsTable_data *StorageNew, *StorageDel;
size_t newlen =
name_len - (sizeof(mteObjectsTable_variables_oid) / sizeof(oid) +
3 - 1);
static int old_value;
int set_value;
static netsnmp_variable_list *vars, *vp;
struct header_complex_index *hciptr;
StorageTmp =
header_complex(mteObjectsTableStorage, NULL,
&name[sizeof(mteObjectsTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
if (var_val_type != ASN_INTEGER || var_val == NULL) {
snmp_log(LOG_ERR,
"write to mteObjectsEntryStatus not ASN_INTEGER\n");
return SNMP_ERR_WRONGTYPE;
}
if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
return SNMP_ERR_NOTWRITABLE;
}
set_value = *((long *) var_val);
/*
* check legal range, and notReady is reserved for us, not a user
*/
if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
return SNMP_ERR_INCONSISTENTVALUE;
switch (action) {
case RESERVE1:
/*
* stage one: test validity
*/
if (StorageTmp == NULL) {
/*
* create the row now?
*/
/*
* ditch illegal values now
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
return SNMP_ERR_INCONSISTENTVALUE;
/*
* destroying a non-existent row is actually legal
*/
if (set_value == RS_DESTROY) {
return SNMP_ERR_NOERROR;
}
/*
* illegal creation values
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else {
/*
* row exists. Check for a valid state change
*/
if (set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT) {
/*
* can't create a row that exists
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
/*
* XXX: interaction with row storage type needed
*/
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
if (StorageTmp == NULL) {
/*
* creation
*/
vars = NULL;
snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* mteOwner */
snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* mteObjectsName */
snmp_varlist_add_variable(&vars, NULL, 0, ASN_UNSIGNED, NULL, 0); /* mteObjectsIndex */
if (header_complex_parse_oid
(&
(name
[sizeof(mteObjectsTable_variables_oid) / sizeof(oid) +
2]), newlen, vars) != SNMPERR_SUCCESS) {
/*
* XXX: free, zero vars
*/
return SNMP_ERR_INCONSISTENTNAME;
}
vp = vars;
StorageNew = SNMP_MALLOC_STRUCT(mteObjectsTable_data);
if (StorageNew == NULL)
return SNMP_ERR_GENERR;
StorageNew->mteOwner = netsnmp_strdup_and_null(vp->val.string,
vp->val_len);
StorageNew->mteOwnerLen = vp->val_len;
vp = vp->next_variable;
StorageNew->mteObjectsName =
netsnmp_strdup_and_null(vp->val.string,
vp->val_len);
StorageNew->mteObjectsNameLen = vp->val_len;
vp = vp->next_variable;
StorageNew->mteObjectsIndex = *(vp->val.integer);
/*
* XXX: fill in default row values here into StorageNew
*/
StorageNew->mteObjectsID = calloc(1, sizeof(oid) * sizeof(2)); /* 0.0 */
StorageNew->mteObjectsIDLen = 2;
StorageNew->mteObjectsIDWildcard = MTEOBJECTSIDWILDCARD_FALSE;
StorageNew->mteObjectsEntryStatus = set_value;
/*
* XXX: free, zero vars, no longer needed?
*/
}
break;
case FREE:
/*
* XXX: free, zero vars
*/
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in set_value for you to
* use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in
* the UNDO case
*/
if (StorageTmp == NULL) {
/*
* row creation, so add it
*/
if (StorageNew != NULL)
mteObjectsTable_add(StorageNew);
/*
* XXX: ack, and if it is NULL?
*/
} else if (set_value != RS_DESTROY) {
/*
* set the flag?
*/
old_value = StorageTmp->mteObjectsEntryStatus;
StorageTmp->mteObjectsEntryStatus = *((long *) var_val);
} else {
/*
* destroy... extract it for now
*/
hciptr =
header_complex_find_entry(mteObjectsTableStorage,
StorageTmp);
StorageDel =
header_complex_extract_entry(&mteObjectsTableStorage,
hciptr);
}
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
if (StorageTmp == NULL) {
/*
* row creation, so remove it again
*/
hciptr =
header_complex_find_entry(mteObjectsTableStorage,
StorageTmp);
StorageDel =
header_complex_extract_entry(&mteObjectsTableStorage,
hciptr);
/*
* XXX: free it
*/
} else if (StorageDel != NULL) {
/*
* row deletion, so add it again
*/
mteObjectsTable_add(StorageDel);
} else {
StorageTmp->mteObjectsEntryStatus = old_value;
}
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
if (StorageDel != NULL) {
StorageDel = 0;
/*
* XXX: free it, its dead
*/
} else {
if (StorageTmp
&& StorageTmp->mteObjectsEntryStatus == RS_CREATEANDGO) {
StorageTmp->mteObjectsEntryStatus = RS_ACTIVE;
} else if (StorageTmp &&
StorageTmp->mteObjectsEntryStatus ==
RS_CREATEANDWAIT) {
StorageTmp->mteObjectsEntryStatus = RS_NOTINSERVICE;
}
}
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
int
write_snmpNotifyFilterMask(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)
{
static char *tmpvar;
struct snmpNotifyFilterTable_data *StorageTmp = NULL;
static size_t tmplen;
size_t newlen =
name_len -
(sizeof(snmpNotifyFilterTable_variables_oid) / sizeof(oid) + 3 -
1);
DEBUGMSGTL(("snmpNotifyFilterTable",
"write_snmpNotifyFilterMask entering action=%d... \n",
action));
if ((StorageTmp = (struct snmpNotifyFilterTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyFilterTableStorage, NULL,
&name[sizeof(snmpNotifyFilterTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL,
NULL)) == NULL)
return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
switch (action) {
case RESERVE1:
if (var_val_type != ASN_OCTET_STR) {
fprintf(stderr,
"write to snmpNotifyFilterMask not ASN_OCTET_STR\n");
return SNMP_ERR_WRONGTYPE;
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
break;
case FREE:
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in string for
* you to use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in the UNDO case
*/
tmpvar = StorageTmp->snmpNotifyFilterMask;
tmplen = StorageTmp->snmpNotifyFilterMaskLen;
memdup((u_char **) & StorageTmp->snmpNotifyFilterMask, var_val,
var_val_len);
StorageTmp->snmpNotifyFilterMaskLen = var_val_len;
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
SNMP_FREE(StorageTmp->snmpNotifyFilterMask);
StorageTmp->snmpNotifyFilterMask = tmpvar;
StorageTmp->snmpNotifyFilterMaskLen = tmplen;
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
SNMP_FREE(tmpvar);
break;
}
return SNMP_ERR_NOERROR;
}
/*
* var_mteObjectsTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_mteObjectsTable above.
*/
unsigned char *
var_mteObjectsTable(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
struct mteObjectsTable_data *StorageTmp = NULL;
DEBUGMSGTL(("mteObjectsTable",
"var_mteObjectsTable: Entering... \n"));
/* set default value */
*write_method = NULL;
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(mteObjectsTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL) {
if (vp->magic == MTEOBJECTSENTRYSTATUS)
*write_method = write_mteObjectsEntryStatus;
return NULL;
}
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case MTEOBJECTSID:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteObjectsID;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = (StorageTmp->mteObjectsIDLen) * sizeof(oid);
return (u_char *) StorageTmp->mteObjectsID;
case MTEOBJECTSIDWILDCARD:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteObjectsIDWildcard;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = sizeof(StorageTmp->mteObjectsIDWildcard);
return (u_char *) & StorageTmp->mteObjectsIDWildcard;
case MTEOBJECTSENTRYSTATUS:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteObjectsEntryStatus;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = sizeof(StorageTmp->mteObjectsEntryStatus);
return (u_char *) & StorageTmp->mteObjectsEntryStatus;
default:
ERROR_MSG("");
}
return NULL;
}
int
write_mteObjectsID(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)
{
static oid *tmpvar;
struct mteObjectsTable_data *StorageTmp = NULL;
static size_t tmplen;
size_t newlen =
name_len - (sizeof(mteObjectsTable_variables_oid) / sizeof(oid) +
3 - 1);
DEBUGMSGTL(("mteObjectsTable",
"write_mteObjectsID entering action=%d... \n", action));
if ((StorageTmp =
header_complex(mteObjectsTableStorage, NULL,
&name[sizeof(mteObjectsTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL,
NULL)) == NULL)
return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
return SNMP_ERR_NOTWRITABLE;
}
switch (action) {
case RESERVE1:
if (var_val_type != ASN_OBJECT_ID) {
snmp_log(LOG_ERR, "write to mteObjectsID not ASN_OBJECT_ID\n");
return SNMP_ERR_WRONGTYPE;
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
break;
case FREE:
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in objid for
* you to use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in the UNDO case
*/
tmpvar = StorageTmp->mteObjectsID;
tmplen = StorageTmp->mteObjectsIDLen;
memdup((u_char **) & StorageTmp->mteObjectsID, var_val,
var_val_len);
StorageTmp->mteObjectsIDLen = var_val_len / sizeof(oid);
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
SNMP_FREE(StorageTmp->mteObjectsID);
StorageTmp->mteObjectsID = tmpvar;
StorageTmp->mteObjectsIDLen = tmplen;
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
SNMP_FREE(tmpvar);
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
/*
* var_mteTriggerDeltaTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_mteTriggerDeltaTable above.
*/
unsigned char *
var_mteTriggerDeltaTable(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
struct mteTriggerTable_data *StorageTmp = NULL;
DEBUGMSGTL(("mteTriggerDeltaTable",
"var_mteTriggerDeltaTable: Entering... \n"));
/* set default value */
*write_method = NULL;
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(mteTriggerTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL)
return NULL;
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case MTETRIGGERDELTADISCONTINUITYID:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerDeltaDiscontinuityID;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len =
StorageTmp->mteTriggerDeltaDiscontinuityIDLen * sizeof(oid);
return (u_char *) StorageTmp->mteTriggerDeltaDiscontinuityID;
case MTETRIGGERDELTADISCONTINUITYIDWILDCARD:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerDeltaDiscontinuityIDWildcard;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len =
sizeof(StorageTmp->mteTriggerDeltaDiscontinuityIDWildcard);
return (u_char *) & StorageTmp->
mteTriggerDeltaDiscontinuityIDWildcard;
case MTETRIGGERDELTADISCONTINUITYIDTYPE:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerDeltaDiscontinuityIDType;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = sizeof(StorageTmp->mteTriggerDeltaDiscontinuityIDType);
return (u_char *) & StorageTmp->mteTriggerDeltaDiscontinuityIDType;
default:
ERROR_MSG("");
}
return NULL;
}
int
write_snmpNotifyFilterProfileRowStatus(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)
{
struct snmpNotifyFilterProfileTable_data *StorageTmp = NULL;
static struct snmpNotifyFilterProfileTable_data *StorageDel;
size_t newlen =
name_len -
(sizeof(snmpNotifyFilterProfileTable_variables_oid) / sizeof(oid) +
3 - 1);
static int old_value;
int set_value = *((long *) var_val);
netsnmp_variable_list *vars;
struct header_complex_index *hciptr;
DEBUGMSGTL(("snmpNotifyFilterProfileTable",
"write_snmpNotifyFilterProfileRowStatus entering action=%d... \n",
action));
StorageTmp = (struct snmpNotifyFilterProfileTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyFilterProfileTableStorage, NULL,
&name[sizeof
(snmpNotifyFilterProfileTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
switch (action) {
case RESERVE1:
if (var_val_type != ASN_INTEGER || var_val == NULL) {
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
return SNMP_ERR_WRONGLENGTH;
}
if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY) {
return SNMP_ERR_WRONGVALUE;
}
/*
* stage one: test validity
*/
if (StorageTmp == NULL) {
/*
* create the row now?
*/
/*
* ditch illegal values now
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else {
/*
* row exists. Check for a valid state change
*/
if (set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT) {
/*
* can't create a row that exists
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
if ((set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) &&
StorageTmp->snmpNotifyFilterProfileNameLen == 0) {
/*
* can't activate row without a profile name
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
/*
* XXX: interaction with row storage type needed
*/
}
/*
* memory reseveration, final preparation...
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT)) {
/*
* creation
*/
vars = NULL;
snmp_varlist_add_variable(&vars, NULL, 0,
ASN_PRIV_IMPLIED_OCTET_STR, NULL, 0);
if (header_complex_parse_oid
(&
(name
[sizeof(snmpNotifyFilterProfileTable_variables_oid) /
sizeof(oid) + 2]), newlen, vars) != SNMPERR_SUCCESS) {
snmp_free_var(vars);
return SNMP_ERR_INCONSISTENTNAME;
}
StorageNew =
SNMP_MALLOC_STRUCT(snmpNotifyFilterProfileTable_data);
if (StorageNew == NULL)
return SNMP_ERR_GENERR;
memdup((u_char **) & (StorageNew->snmpTargetParamsName),
vars->val.string, vars->val_len);
StorageNew->snmpTargetParamsNameLen = vars->val_len;
StorageNew->snmpNotifyFilterProfileStorType = ST_NONVOLATILE;
StorageNew->snmpNotifyFilterProfileRowStatus = RS_NOTREADY;
snmp_free_var(vars);
}
break;
case RESERVE2:
break;
case FREE:
/*
* XXX: free, zero vars
*/
/*
* Release any resources that have been allocated
*/
if (StorageNew != NULL) {
SNMP_FREE(StorageNew->snmpTargetParamsName);
SNMP_FREE(StorageNew->snmpNotifyFilterProfileName);
free(StorageNew);
StorageNew = NULL;
}
break;
case ACTION:
/*
* The variable has been stored in set_value for you to
* use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in
* the UNDO case
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO ||
set_value == RS_CREATEANDWAIT)) {
/*
* row creation, so add it
*/
if (StorageNew != NULL)
snmpNotifyFilterProfileTable_add(StorageNew);
/*
* XXX: ack, and if it is NULL?
*/
} else if (set_value != RS_DESTROY) {
/*
* set the flag?
*/
if (StorageTmp == NULL)
return SNMP_ERR_GENERR; /* should never ever get here */
old_value = StorageTmp->snmpNotifyFilterProfileRowStatus;
StorageTmp->snmpNotifyFilterProfileRowStatus =
*((long *) var_val);
} else {
/*
* destroy... extract it for now
*/
if (StorageTmp) {
hciptr =
header_complex_find_entry
(snmpNotifyFilterProfileTableStorage, StorageTmp);
StorageDel = (struct snmpNotifyFilterProfileTable_data *)
header_complex_extract_entry((struct
header_complex_index **)
&snmpNotifyFilterProfileTableStorage,
hciptr);
}
}
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO ||
set_value == RS_CREATEANDWAIT)) {
/*
* row creation, so remove it again
*/
hciptr =
header_complex_find_entry
(snmpNotifyFilterProfileTableStorage, StorageNew);
StorageDel = (struct snmpNotifyFilterProfileTable_data *)
header_complex_extract_entry((struct header_complex_index
**)
&snmpNotifyFilterProfileTableStorage,
hciptr);
/*
* XXX: free it
*/
} else if (StorageDel != NULL) {
/*
* row deletion, so add it again
*/
snmpNotifyFilterProfileTable_add(StorageDel);
StorageDel = NULL;
} else if (set_value != RS_DESTROY) {
if (StorageTmp)
StorageTmp->snmpNotifyFilterProfileRowStatus = old_value;
}
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
if (StorageDel != NULL) {
SNMP_FREE(StorageDel->snmpTargetParamsName);
SNMP_FREE(StorageDel->snmpNotifyFilterProfileName);
free(StorageDel);
StorageDel = NULL;
}
if (StorageTmp && set_value == RS_CREATEANDGO) {
if (StorageTmp->snmpNotifyFilterProfileNameLen)
StorageTmp->snmpNotifyFilterProfileRowStatus = RS_ACTIVE;
StorageNew = NULL;
} else if (StorageTmp && set_value == RS_CREATEANDWAIT) {
if (StorageTmp->snmpNotifyFilterProfileNameLen)
StorageTmp->snmpNotifyFilterProfileRowStatus = RS_NOTINSERVICE;
StorageNew = NULL;
}
break;
}
return SNMP_ERR_NOERROR;
}
int
write_snmpNotifyFilterProfileStorType(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)
{
static int tmpvar;
long value = *((long *) var_val);
struct snmpNotifyFilterProfileTable_data *StorageTmp = NULL;
size_t newlen =
name_len -
(sizeof(snmpNotifyFilterProfileTable_variables_oid) / sizeof(oid) +
3 - 1);
DEBUGMSGTL(("snmpNotifyFilterProfileTable",
"write_snmpNotifyFilterProfileStorType entering action=%d... \n",
action));
if (action != RESERVE1 &&
(StorageTmp = (struct snmpNotifyFilterProfileTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyFilterProfileTableStorage, NULL,
&name[sizeof
(snmpNotifyFilterProfileTable_variables_oid)
/ sizeof(oid) + 3 - 1], &newlen, 1, NULL,
NULL)) == NULL) {
if ((StorageTmp = StorageNew) == NULL)
return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
}
switch (action) {
case RESERVE1:
if (var_val_type != ASN_INTEGER) {
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
return SNMP_ERR_WRONGLENGTH;
}
if (value != SNMP_STORAGE_OTHER && value != SNMP_STORAGE_VOLATILE
&& value != SNMP_STORAGE_NONVOLATILE) {
return SNMP_ERR_WRONGVALUE;
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
break;
case FREE:
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in long_ret for
* you to use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in the UNDO case
*/
tmpvar = StorageTmp->snmpNotifyFilterProfileStorType;
StorageTmp->snmpNotifyFilterProfileStorType = *((long *) var_val);
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
StorageTmp->snmpNotifyFilterProfileStorType = tmpvar;
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
break;
}
return SNMP_ERR_NOERROR;
}
int
write_expExpressionEntryStatus(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)
{
struct expExpressionTable_data *StorageTmp = NULL;
static struct expExpressionTable_data *StorageNew, *StorageDel;
size_t newlen =
name_len -
(sizeof(expExpressionTable_variables_oid) / sizeof(oid) + 3 - 1);
static int old_value;
int set_value;
static netsnmp_variable_list *vars, *vp;
struct header_complex_index *hciptr;
StorageTmp =
header_complex(expExpressionTableStorage, NULL,
&name[sizeof(expExpressionTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
if (var_val_type != ASN_INTEGER || var_val == NULL) {
snmp_log(LOG_ERR,
"write to expExpressionEntryStatus not ASN_INTEGER\n");
return SNMP_ERR_WRONGTYPE;
}
set_value = *((long *) var_val);
/*
* check legal range, and notReady is reserved for us, not a user
*/
if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
return SNMP_ERR_INCONSISTENTVALUE;
switch (action) {
case RESERVE1:
/*
* stage one: test validity
*/
if (StorageTmp == NULL) {
/*
* create the row now?
*/
/*
* ditch illegal values now
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
return SNMP_ERR_INCONSISTENTVALUE;
/*
* destroying a non-existent row is actually legal
*/
if (set_value == RS_DESTROY) {
return SNMP_ERR_NOERROR;
}
/*
* illegal creation values
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else {
/*
* row exists. Check for a valid state change
*/
if (set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT) {
/*
* can't create a row that exists
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
if (StorageTmp->expExpressionEntryStatus == RS_ACTIVE &&
set_value != RS_DESTROY) {
/*
* "Once made active an entry may not be modified except to
* delete it." XXX: doesn't this in fact apply to ALL
* columns of the table and not just this one?
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
if (StorageTmp->storageType != ST_NONVOLATILE)
return SNMP_ERR_NOTWRITABLE;
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
if (StorageTmp == NULL) {
/*
* creation
*/
vars = NULL;
snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* expExpressionOwner */
snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* expExpressionName */
if (header_complex_parse_oid
(&
(name
[sizeof(expExpressionTable_variables_oid) / sizeof(oid) +
2]), newlen, vars) != SNMPERR_SUCCESS) {
/*
* XXX: free, zero vars
*/
return SNMP_ERR_INCONSISTENTNAME;
}
vp = vars;
StorageNew = create_expExpressionTable_data();
StorageNew->expExpressionOwner = malloc(vp->val_len + 1);
memcpy(StorageNew->expExpressionOwner, vp->val.string,
vp->val_len);
StorageNew->expExpressionOwner[vp->val_len] = '\0';
StorageNew->expExpressionOwnerLen = vp->val_len;
vp = vp->next_variable;
StorageNew->expExpressionName = malloc(vp->val_len + 1);
memcpy(StorageNew->expExpressionName, vp->val.string,
vp->val_len);
StorageNew->expExpressionName[vp->val_len] = '\0';
StorageNew->expExpressionNameLen = vp->val_len;
vp = vp->next_variable;
StorageNew->expExpressionEntryStatus = set_value;
}
break;
case FREE:
/*
* XXX: free, zero vars
*/
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in set_value for you to
* use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in
* the UNDO case
*/
if (StorageTmp == NULL) {
/*
* row creation, so add it
*/
if (StorageNew != NULL)
expExpressionTable_add(StorageNew);
/*
* XXX: ack, and if it is NULL?
*/
} else if (set_value != RS_DESTROY) {
/*
* set the flag?
*/
old_value = StorageTmp->expExpressionEntryStatus;
StorageTmp->expExpressionEntryStatus = *((long *) var_val);
} else {
/*
* destroy... extract it for now
*/
hciptr =
header_complex_find_entry(expExpressionTableStorage,
StorageTmp);
StorageDel =
header_complex_extract_entry(&expExpressionTableStorage,
hciptr);
}
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
if (StorageTmp == NULL) {
/*
* row creation, so remove it again
*/
hciptr =
header_complex_find_entry(expExpressionTableStorage,
StorageTmp);
StorageDel =
header_complex_extract_entry(&expExpressionTableStorage,
hciptr);
/*
* XXX: free it
*/
} else if (StorageDel != NULL) {
/*
* row deletion, so add it again
*/
expExpressionTable_add(StorageDel);
} else {
StorageTmp->expExpressionEntryStatus = old_value;
}
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
if (StorageDel != NULL) {
StorageDel = 0;
/*
* XXX: free it, its dead
*/
} else {
if (StorageTmp
&& StorageTmp->expExpressionEntryStatus ==
RS_CREATEANDGO) {
StorageTmp->expExpressionEntryStatus = RS_ACTIVE;
} else if (StorageTmp &&
StorageTmp->expExpressionEntryStatus ==
RS_CREATEANDWAIT) {
StorageTmp->expExpressionEntryStatus = RS_NOTINSERVICE;
}
}
if (StorageTmp &&
StorageTmp->expExpressionEntryStatus == RS_ACTIVE &&
!StorageTmp->have_copied_auth_info) {
netsnmp_agent_session *asp =
netsnmp_get_current_agent_session();
netsnmp_pdu *pdu = NULL;
if (!asp) {
snmp_log(LOG_ERR,
"snmpTriggerTable: can't get master session for authentication params\n");
} else {
pdu = asp->orig_pdu;
if (!pdu) {
snmp_log(LOG_ERR,
"snmpTriggerTable: can't get master pdu for authentication params\n");
}
}
if (pdu) {
DEBUGMSGTL(("expExpressionTest",
"copying PDU auth info\n"));
StorageTmp->pdu_version = pdu->version;
StorageTmp->pdu_securityModel = pdu->securityModel;
StorageTmp->pdu_securityLevel = pdu->securityLevel;
StorageTmp->pdu_tDomain = pdu->tDomain;
StorageTmp->pdu_tDomainLen = pdu->tDomainLen;
if (pdu->transport_data != NULL) {
StorageTmp->pdu_transport =
malloc(pdu->transport_data_length);
memcpy(StorageTmp->pdu_transport, pdu->transport_data,
pdu->transport_data_length);
}
StorageTmp->pdu_transportLen = pdu->transport_data_length;
if (pdu->community) {
StorageTmp->pdu_community =
calloc(1, pdu->community_len + 1);
memcpy(StorageTmp->pdu_community, pdu->community,
pdu->community_len);
StorageTmp->pdu_community_len = pdu->community_len;
} else {
StorageTmp->pdu_community = NULL;
StorageTmp->pdu_community_len = 0;
}
if (pdu->securityName) {
StorageTmp->pdu_securityName =
calloc(1, pdu->securityNameLen + 1);
memcpy(StorageTmp->pdu_securityName, pdu->securityName,
pdu->securityNameLen);
StorageTmp->pdu_securityNameLen = pdu->securityNameLen;
} else {
StorageTmp->pdu_securityName = NULL;
StorageTmp->pdu_securityNameLen = 0;
}
StorageTmp->have_copied_auth_info = 1;
}
}
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
/*
* var_traceRouteHopsTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_traceRouteHopsTable above.
*/
unsigned char *
var_traceRouteHopsTable(struct variable *vp,
oid * name,
size_t *length,
int exact,
size_t *var_len, WriteMethod ** write_method)
{
struct traceRouteHopsTable_data *StorageTmp = NULL;
*write_method = NULL;
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(traceRouteHopsTableStorage, vp, name, length,
exact, var_len, write_method)) == NULL) {
return NULL;
}
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case COLUMN_TRACEROUTEHOPSIPTGTADDRESSTYPE:
*var_len = sizeof(StorageTmp->traceRouteHopsIpTgtAddressType);
return (u_char *) & StorageTmp->traceRouteHopsIpTgtAddressType;
case COLUMN_TRACEROUTEHOPSIPTGTADDRESS:
*var_len = (StorageTmp->traceRouteHopsIpTgtAddressLen);
return (u_char *) StorageTmp->traceRouteHopsIpTgtAddress;
case COLUMN_TRACEROUTEHOPSMINRTT:
*var_len = sizeof(StorageTmp->traceRouteHopsMinRtt);
return (u_char *) & StorageTmp->traceRouteHopsMinRtt;
case COLUMN_TRACEROUTEHOPSMAXRTT:
*var_len = sizeof(StorageTmp->traceRouteHopsMaxRtt);
return (u_char *) & StorageTmp->traceRouteHopsMaxRtt;
case COLUMN_TRACEROUTEHOPSAVERAGERTT:
*var_len = sizeof(StorageTmp->traceRouteHopsAverageRtt);
return (u_char *) & StorageTmp->traceRouteHopsAverageRtt;
case COLUMN_TRACEROUTEHOPSRTTSUMOFSQUARES:
*var_len = sizeof(StorageTmp->traceRouteHopsRttSumOfSquares);
return (u_char *) & StorageTmp->traceRouteHopsRttSumOfSquares;
case COLUMN_TRACEROUTEHOPSSENTPROBES:
*var_len = sizeof(StorageTmp->traceRouteHopsSentProbes);
return (u_char *) & StorageTmp->traceRouteHopsSentProbes;
case COLUMN_TRACEROUTEHOPSPROBERESPONSES:
*var_len = sizeof(StorageTmp->traceRouteHopsProbeResponses);
return (u_char *) & StorageTmp->traceRouteHopsProbeResponses;
case COLUMN_TRACEROUTEHOPSLASTGOODPROBE:
*var_len = (StorageTmp->traceRouteHopsLastGoodProbeLen);
return (u_char *) StorageTmp->traceRouteHopsLastGoodProbe;
default:
ERROR_MSG("");
}
return NULL;
}
/*
* var_traceRouteResultsTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_traceRouteResultsTable above.
*/
unsigned char *
var_traceRouteResultsTable(struct variable *vp,
oid * name,
size_t *length,
int exact,
size_t *var_len, WriteMethod ** write_method)
{
struct traceRouteResultsTable_data *StorageTmp = NULL;
*write_method = NULL;
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(traceRouteResultsTableStorage, vp, name, length,
exact, var_len, write_method)) == NULL) {
return NULL;
}
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case COLUMN_TRACEROUTERESULTSOPERSTATUS:
*var_len = sizeof(StorageTmp->traceRouteResultsOperStatus);
return (u_char *) & StorageTmp->traceRouteResultsOperStatus;
case COLUMN_TRACEROUTERESULTSCURHOPCOUNT:
*var_len = sizeof(StorageTmp->traceRouteResultsCurHopCount);
return (u_char *) & StorageTmp->traceRouteResultsCurHopCount;
case COLUMN_TRACEROUTERESULTSCURPROBECOUNT:
*var_len = sizeof(StorageTmp->traceRouteResultsCurProbeCount);
return (u_char *) & StorageTmp->traceRouteResultsCurProbeCount;
case COLUMN_TRACEROUTERESULTSIPTGTADDRTYPE:
*var_len = sizeof(StorageTmp->traceRouteResultsIpTgtAddrType);
return (u_char *) & StorageTmp->traceRouteResultsIpTgtAddrType;
case COLUMN_TRACEROUTERESULTSIPTGTADDR:
*var_len = (StorageTmp->traceRouteResultsIpTgtAddrLen);
return (u_char *) StorageTmp->traceRouteResultsIpTgtAddr;
case COLUMN_TRACEROUTERESULTSTESTATTEMPTS:
*var_len = sizeof(StorageTmp->traceRouteResultsTestAttempts);
return (u_char *) & StorageTmp->traceRouteResultsTestAttempts;
case COLUMN_TRACEROUTERESULTSTESTSUCCESSES:
*var_len = sizeof(StorageTmp->traceRouteResultsTestSuccesses);
return (u_char *) & StorageTmp->traceRouteResultsTestSuccesses;
case COLUMN_TRACEROUTERESULTSLASTGOODPATH:
*var_len = (StorageTmp->traceRouteResultsLastGoodPathLen);
return (u_char *) StorageTmp->traceRouteResultsLastGoodPath;
default:
ERROR_MSG("");
}
return NULL;
}
/*
* var_mteTriggerBooleanTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_mteTriggerBooleanTable above.
*/
unsigned char *var_mteTriggerBooleanTable (struct variable *vp,
oid * name,
size_t * length, int exact, size_t * var_len, WriteMethod ** write_method)
{
struct mteTriggerTable_data *StorageTmp = NULL;
DEBUGMSGTL (("mteTriggerBooleanTable", "var_mteTriggerBooleanTable: Entering... \n"));
/* set default value */
*write_method = NULL;
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp = header_complex (mteTriggerTableStorage, vp, name, length, exact, var_len, write_method)) == NULL)
return NULL;
if (!(StorageTmp->mteTriggerTest[0] & MTETRIGGERTEST_BOOLEAN))
return NULL;
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic)
{
case MTETRIGGERBOOLEANCOMPARISON:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanComparison;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = sizeof (StorageTmp->mteTriggerBooleanComparison);
return (u_char *) & StorageTmp->mteTriggerBooleanComparison;
case MTETRIGGERBOOLEANVALUE:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanValue;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = sizeof (StorageTmp->mteTriggerBooleanValue);
return (u_char *) & StorageTmp->mteTriggerBooleanValue;
case MTETRIGGERBOOLEANSTARTUP:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanStartup;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = sizeof (StorageTmp->mteTriggerBooleanStartup);
return (u_char *) & StorageTmp->mteTriggerBooleanStartup;
case MTETRIGGERBOOLEANOBJECTSOWNER:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanObjectsOwner;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = StorageTmp->mteTriggerBooleanObjectsOwnerLen;
return (u_char *) StorageTmp->mteTriggerBooleanObjectsOwner;
case MTETRIGGERBOOLEANOBJECTS:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanObjects;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = StorageTmp->mteTriggerBooleanObjectsLen;
return (u_char *) StorageTmp->mteTriggerBooleanObjects;
case MTETRIGGERBOOLEANEVENTOWNER:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanEventOwner;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = StorageTmp->mteTriggerBooleanEventOwnerLen;
return (u_char *) StorageTmp->mteTriggerBooleanEventOwner;
case MTETRIGGERBOOLEANEVENT:
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_mteTriggerBooleanEvent;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
*var_len = StorageTmp->mteTriggerBooleanEventLen;
return (u_char *) StorageTmp->mteTriggerBooleanEvent;
default:
ERROR_MSG ("");
}
return NULL;
}
int
write_snmpNotifyFilterRowStatus(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)
{
struct snmpNotifyFilterTable_data *StorageTmp = NULL;
static struct snmpNotifyFilterTable_data *StorageNew, *StorageDel;
size_t newlen =
name_len -
(sizeof(snmpNotifyFilterTable_variables_oid) / sizeof(oid) + 3 -
1);
static int old_value;
int set_value;
static netsnmp_variable_list *vars, *vp;
struct header_complex_index *hciptr;
StorageTmp = (struct snmpNotifyFilterTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyFilterTableStorage, NULL,
&name[sizeof(snmpNotifyFilterTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
if (var_val_type != ASN_INTEGER || var_val == NULL) {
fprintf(stderr,
"write to snmpNotifyFilterRowStatus not ASN_INTEGER\n");
return SNMP_ERR_WRONGTYPE;
}
set_value = *((long *) var_val);
/*
* check legal range, and notReady is reserved for us, not a user
*/
if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
return SNMP_ERR_INCONSISTENTVALUE;
switch (action) {
case RESERVE1:
/*
* stage one: test validity
*/
if (StorageTmp == NULL) {
/*
* create the row now?
*/
/*
* ditch illegal values now
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
return SNMP_ERR_INCONSISTENTVALUE;
} else {
/*
* row exists. Check for a valid state change
*/
if (set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT) {
/*
* can't create a row that exists
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
/*
* XXX: interaction with row storage type needed
*/
}
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT)) {
/*
* creation
*/
vars = NULL;
snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0); /* snmpNotifyFilterSubtree */
snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OBJECT_ID, NULL, 0); /* snmpNotifyFilterSubtree */
if (header_complex_parse_oid
(&
(name
[sizeof(snmpNotifyFilterTable_variables_oid) /
sizeof(oid) + 2]), newlen, vars) != SNMPERR_SUCCESS) {
/*
* XXX: free, zero vars
*/
return SNMP_ERR_INCONSISTENTNAME;
}
vp = vars;
StorageNew = SNMP_MALLOC_STRUCT(snmpNotifyFilterTable_data);
memdup((u_char **) & (StorageNew->snmpNotifyFilterProfileName),
(u_char *) vp->val.string, vp->val_len);
StorageNew->snmpNotifyFilterProfileNameLen = vp->val_len;
vp = vp->next_variable;
memdup((u_char **) & (StorageNew->snmpNotifyFilterSubtree),
(u_char *) vp->val.objid, vp->val_len);
StorageNew->snmpNotifyFilterSubtreeLen =
vp->val_len / sizeof(oid);
StorageNew->snmpNotifyFilterMask = (char *) calloc(1, 1);
StorageNew->snmpNotifyFilterMaskLen = 0;
StorageNew->snmpNotifyFilterType =
SNMPNOTIFYFILTERTYPE_INCLUDED;
StorageNew->snmpNotifyFilterStorageType = ST_NONVOLATILE;
StorageNew->snmpNotifyFilterRowStatus = set_value;
/*
* XXX: free, zero vars, no longer needed?
*/
}
break;
case FREE:
/*
* XXX: free, zero vars
*/
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in set_value for you to
* use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in
* the UNDO case
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO ||
set_value == RS_CREATEANDWAIT)) {
/*
* row creation, so add it
*/
if (StorageNew != NULL)
snmpNotifyFilterTable_add(StorageNew);
/*
* XXX: ack, and if it is NULL?
*/
} else if (set_value != RS_DESTROY) {
/*
* set the flag?
*/
old_value = StorageTmp->snmpNotifyFilterRowStatus;
StorageTmp->snmpNotifyFilterRowStatus = *((long *) var_val);
} else {
/*
* destroy... extract it for now
*/
if (StorageTmp) {
hciptr =
header_complex_find_entry(snmpNotifyFilterTableStorage,
StorageTmp);
StorageDel = (struct snmpNotifyFilterTable_data *)
header_complex_extract_entry((struct
header_complex_index **)
&snmpNotifyFilterTableStorage,
hciptr);
}
}
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO ||
set_value == RS_CREATEANDWAIT)) {
/*
* row creation, so remove it again
*/
hciptr =
header_complex_find_entry(snmpNotifyFilterTableStorage,
StorageNew);
StorageDel = (struct snmpNotifyFilterTable_data *)
header_complex_extract_entry((struct header_complex_index
**)
&snmpNotifyFilterTableStorage,
hciptr);
/*
* XXX: free it
*/
} else if (StorageDel != NULL) {
/*
* row deletion, so add it again
*/
snmpNotifyFilterTable_add(StorageDel);
StorageDel = NULL;
} else if (set_value != RS_DESTROY) {
StorageTmp->snmpNotifyFilterRowStatus = old_value;
}
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
if (StorageDel != NULL) {
StorageDel = NULL;
/*
* XXX: free it, its dead
*/
} else {
if (StorageTmp
&& StorageTmp->snmpNotifyFilterRowStatus ==
RS_CREATEANDGO) {
StorageTmp->snmpNotifyFilterRowStatus = RS_ACTIVE;
} else if (StorageTmp &&
StorageTmp->snmpNotifyFilterRowStatus ==
RS_CREATEANDWAIT) {
StorageTmp->snmpNotifyFilterRowStatus = RS_NOTINSERVICE;
}
}
break;
}
return SNMP_ERR_NOERROR;
}
int
write_snmpNotifyRowStatus(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)
{
struct snmpNotifyTable_data *StorageTmp = NULL;
static struct snmpNotifyTable_data *StorageDel;
size_t newlen =
name_len - (sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
3 - 1);
static int old_value;
int set_value = *((long *) var_val);
static netsnmp_variable_list *vars, *vp;
struct header_complex_index *hciptr;
DEBUGMSGTL(("snmpNotifyTable",
"write_snmpNotifyRowStatus entering action=%d... \n",
action));
StorageTmp = (struct snmpNotifyTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyTableStorage, NULL,
&name[sizeof(snmpNotifyTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
switch (action) {
case RESERVE1:
if (var_val_type != ASN_INTEGER || var_val == NULL) {
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
return SNMP_ERR_WRONGLENGTH;
}
if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY) {
return SNMP_ERR_WRONGVALUE;
}
if (StorageTmp == NULL) {
/*
* create the row now?
*/
/*
* ditch illegal values now
*/
if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else {
/*
* row exists. Check for a valid state change
*/
if (set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT) {
/*
* can't create a row that exists
*/
return SNMP_ERR_INCONSISTENTVALUE;
}
/*
* XXX: interaction with row storage type needed
*/
}
/*
* memory reseveration, final preparation...
*/
if (StorageTmp == NULL &&
(set_value == RS_CREATEANDGO
|| set_value == RS_CREATEANDWAIT)) {
/*
* creation
*/
vars = NULL;
snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, NULL, 0); /* snmpNotifyName */
if (header_complex_parse_oid
(&
(name
[sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
2]), newlen, vars) != SNMPERR_SUCCESS) {
/*
* XXX: free, zero vars
*/
snmp_free_var(vars);
return SNMP_ERR_INCONSISTENTNAME;
}
vp = vars;
StorageNew = SNMP_MALLOC_STRUCT(snmpNotifyTable_data);
if (StorageNew == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
StorageNew->snmpNotifyName = (char*)calloc( 1, vp->val_len + 1 );
if (StorageNew->snmpNotifyName == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
memcpy(StorageNew->snmpNotifyName, vp->val.string, vp->val_len);
StorageNew->snmpNotifyNameLen = vp->val_len;
vp = vp->next_variable;
/*
* default values
*/
StorageNew->snmpNotifyStorageType = ST_NONVOLATILE;
StorageNew->snmpNotifyType = SNMPNOTIFYTYPE_TRAP;
StorageNew->snmpNotifyTagLen = 0;
StorageNew->snmpNotifyTag = (char *) calloc(sizeof(char), 1);
if (StorageNew->snmpNotifyTag == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
StorageNew->snmpNotifyRowStatus = set_value;
snmp_free_var(vars);
}
break;
case RESERVE2:
break;
case FREE:
if (StorageNew != NULL) {
SNMP_FREE(StorageNew->snmpNotifyTag);
SNMP_FREE(StorageNew->snmpNotifyName);
free(StorageNew);
StorageNew = NULL;
}
break;
case ACTION:
if (StorageTmp == NULL && (set_value == RS_CREATEANDGO ||
set_value == RS_CREATEANDWAIT)) {
/*
* row creation, so add it
*/
if (StorageNew != NULL) {
snmpNotifyTable_add(StorageNew);
}
} else if (set_value != RS_DESTROY) {
/*
* set the flag?
*/
if (StorageTmp == NULL)
return SNMP_ERR_GENERR; /* should never ever get here */
old_value = StorageTmp->snmpNotifyRowStatus;
StorageTmp->snmpNotifyRowStatus = *((long *) var_val);
} else {
/*
* destroy... extract it for now
*/
if (StorageTmp) {
hciptr = header_complex_find_entry(snmpNotifyTableStorage,
StorageTmp);
StorageDel = (struct snmpNotifyTable_data *)
header_complex_extract_entry((struct
header_complex_index **)
&snmpNotifyTableStorage,
hciptr);
}
}
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
if (StorageTmp == NULL && (set_value == RS_CREATEANDGO ||
set_value == RS_CREATEANDWAIT)) {
/*
* row creation, so remove it again
*/
hciptr = header_complex_find_entry(snmpNotifyTableStorage,
StorageNew);
StorageDel = (struct snmpNotifyTable_data *)
header_complex_extract_entry((struct header_complex_index
**) &snmpNotifyTableStorage,
hciptr);
/*
* XXX: free it
*/
} else if (StorageDel != NULL) {
/*
* row deletion, so add it again
*/
snmpNotifyTable_add(StorageDel);
} else if (set_value != RS_DESTROY) {
if (StorageTmp)
StorageTmp->snmpNotifyRowStatus = old_value;
}
break;
case COMMIT:
if (StorageDel != NULL) {
SNMP_FREE(StorageDel->snmpNotifyTag);
SNMP_FREE(StorageDel->snmpNotifyName);
free(StorageDel);
StorageDel = NULL;
}
if (StorageTmp
&& StorageTmp->snmpNotifyRowStatus == RS_CREATEANDGO) {
StorageTmp->snmpNotifyRowStatus = RS_ACTIVE;
StorageNew = NULL;
} else if (StorageTmp &&
StorageTmp->snmpNotifyRowStatus == RS_CREATEANDWAIT) {
StorageTmp->snmpNotifyRowStatus = RS_NOTINSERVICE;
StorageNew = NULL;
}
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
/*
* var_pingResultsTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_pingResultsTable above.
*/
unsigned char *
var_pingResultsTable(struct variable *vp,
oid * name,
size_t *length,
int exact,
size_t *var_len, WriteMethod ** write_method)
{
struct pingResultsTable_data *StorageTmp = NULL;
*write_method = NULL;
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(pingResultsTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL) {
return NULL;
}
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case COLUMN_PINGRESULTSOPERSTATUS:
*var_len = sizeof(StorageTmp->pingResultsOperStatus);
return (u_char *) & StorageTmp->pingResultsOperStatus;
case COLUMN_PINGRESULTSIPTARGETADDRESSTYPE:
*var_len = sizeof(StorageTmp->pingResultsIpTargetAddressType);
return (u_char *) & StorageTmp->pingResultsIpTargetAddressType;
case COLUMN_PINGRESULTSIPTARGETADDRESS:
*var_len = (StorageTmp->pingResultsIpTargetAddressLen);
return (u_char *) StorageTmp->pingResultsIpTargetAddress;
case COLUMN_PINGRESULTSMINRTT:
*var_len = sizeof(StorageTmp->pingResultsMinRtt);
return (u_char *) & StorageTmp->pingResultsMinRtt;
case COLUMN_PINGRESULTSMAXRTT:
*var_len = sizeof(StorageTmp->pingResultsMaxRtt);
return (u_char *) & StorageTmp->pingResultsMaxRtt;
case COLUMN_PINGRESULTSAVERAGERTT:
*var_len = sizeof(StorageTmp->pingResultsAverageRtt);
return (u_char *) & StorageTmp->pingResultsAverageRtt;
case COLUMN_PINGRESULTSPROBERESPONSES:
*var_len = sizeof(StorageTmp->pingResultsProbeResponses);
return (u_char *) & StorageTmp->pingResultsProbeResponses;
case COLUMN_PINGRESULTSSENTPROBES:
*var_len = sizeof(StorageTmp->pingResultsSendProbes);
return (u_char *) & StorageTmp->pingResultsSendProbes;
case COLUMN_PINGRESULTSRTTSUMOFSQUARES:
*var_len = sizeof(StorageTmp->pingResultsRttSumOfSquares);
return (u_char *) & StorageTmp->pingResultsRttSumOfSquares;
case COLUMN_PINGRESULTSLASTGOODPROBE:
*var_len = (StorageTmp->pingResultsLastGoodProbeLen);
return (u_char *) StorageTmp->pingResultsLastGoodProbe;
default:
ERROR_MSG("");
}
return NULL;
}
/*
* var_snmpNotifyTable():
* Handle this table separately from the scalar value case.
* The workings of this are basically the same as for var_snmpNotifyTable above.
*/
unsigned char *
var_snmpNotifyTable(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
struct snmpNotifyTable_data *StorageTmp = NULL;
int found = 1;
DEBUGMSGTL(("snmpNotifyTable",
"var_snmpNotifyTable: Entering... \n"));
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp = (struct snmpNotifyTable_data *)
header_complex((struct header_complex_index *)
snmpNotifyTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL) {
found = 0;
}
switch (vp->magic) {
#ifndef NETSNMP_NO_WRITE_SUPPORT
case SNMPNOTIFYTAG:
*write_method = write_snmpNotifyTag;
break;
case SNMPNOTIFYTYPE:
*write_method = write_snmpNotifyType;
break;
case SNMPNOTIFYSTORAGETYPE:
*write_method = write_snmpNotifyStorageType;
break;
case SNMPNOTIFYROWSTATUS:
*write_method = write_snmpNotifyRowStatus;
break;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
default:
*write_method = NULL;
}
if (!found) {
return NULL;
}
#ifndef NETSNMP_NO_READ_SUPPORT
switch (vp->magic) {
case SNMPNOTIFYTAG:
*var_len = StorageTmp->snmpNotifyTagLen;
return (u_char *) StorageTmp->snmpNotifyTag;
case SNMPNOTIFYTYPE:
*var_len = sizeof(StorageTmp->snmpNotifyType);
return (u_char *) & StorageTmp->snmpNotifyType;
case SNMPNOTIFYSTORAGETYPE:
*var_len = sizeof(StorageTmp->snmpNotifyStorageType);
return (u_char *) & StorageTmp->snmpNotifyStorageType;
case SNMPNOTIFYROWSTATUS:
*var_len = sizeof(StorageTmp->snmpNotifyRowStatus);
return (u_char *) & StorageTmp->snmpNotifyRowStatus;
default:
ERROR_MSG("");
}
#endif /* !NETSNMP_NO_READ_SUPPORT */
return NULL;
}
int
write_mteTriggerThresholdStartup(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)
{
static int tmpvar;
struct mteTriggerTable_data *StorageTmp = NULL;
size_t newlen =
name_len -
(sizeof(mteTriggerThresholdTable_variables_oid) / sizeof(oid) + 3 -
1);
DEBUGMSGTL(("mteTriggerThresholdTable",
"write_mteTriggerThresholdStartup entering action=%d... \n",
action));
if ((StorageTmp =
header_complex(mteTriggerTableStorage, NULL,
&name[sizeof
(mteTriggerThresholdTable_variables_oid) /
sizeof(oid) + 3 - 1], &newlen, 1, NULL,
NULL)) == NULL)
return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
switch (action) {
case RESERVE1:
if (var_val_type != ASN_INTEGER) {
fprintf(stderr,
"write to mteTriggerThresholdStartup not ASN_INTEGER\n");
return SNMP_ERR_WRONGTYPE;
}
if (StorageTmp->storageType != ST_NONVOLATILE)
return SNMP_ERR_NOTWRITABLE;
break;
case RESERVE2:
/*
* memory reseveration, final preparation...
*/
break;
case FREE:
/*
* Release any resources that have been allocated
*/
break;
case ACTION:
/*
* The variable has been stored in long_ret for
* you to use, and you have just been asked to do something with
* it. Note that anything done here must be reversable in the UNDO case
*/
tmpvar = StorageTmp->mteTriggerThresholdStartup;
StorageTmp->mteTriggerThresholdStartup = *((long *) var_val);
break;
case UNDO:
/*
* Back out any changes made in the ACTION case
*/
StorageTmp->mteTriggerThresholdStartup = tmpvar;
break;
case COMMIT:
/*
* Things are working well, so it's now safe to make the change
* permanently. Make sure that anything done here can't fail!
*/
break;
}
return SNMP_ERR_NOERROR;
}
static unsigned char *var_expValueTable(struct variable *vp, oid * name,
size_t *length, int exact,
size_t *var_len,
WriteMethod ** write_method)
{
struct expValueTable_data *StorageTmp = NULL;
DEBUGMSGTL(("expValueTable", "var_expValueTable: Entering... \n"));
struct header_complex_index *hciptr, *hciptrn;
for (hciptr = expValueTableStorage; hciptr; hciptr = hciptr->next) {
StorageTmp = hciptr->data;
StorageTmp->set = 0;
}
build_valuetable();
for (hciptr = expValueTableStorage; hciptr; hciptr = hciptrn) {
hciptrn = hciptr->next;
StorageTmp = hciptr->data;
if (!StorageTmp->set)
header_complex_free_entry(hciptr, expValueTable_clean);
}
/*
* this assumes you have registered all your data properly
*/
if ((StorageTmp =
header_complex(expValueTableStorage, vp, name, length, exact,
var_len, write_method)) == NULL) {
DEBUGMSGTL(("expValueTable", "%s: entry not found.\n", __func__));
return NULL;
}
DEBUGMSGTL(("expValueTable", "%s: vp->magic = %d.\n", __func__, vp->magic));
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
/*
* we only support counter32val
*/
case EXPVALUECOUNTER32VAL:
StorageTmp->expValueCounter32Val = Evaluate_Expression(StorageTmp);
*var_len = sizeof(StorageTmp->expValueCounter32Val);
return (u_char *) & StorageTmp->expValueCounter32Val;
case EXPVALUEUNSIGNED32VAL:
/* var_len = sizeof(StorageTmp->expValueUnsigned32Val); */
/* return (u_char *) & StorageTmp->expValueUnsigned32Val; */
return NULL;
case EXPVALUETIMETICKSVAL:
/* var_len = sizeof(StorageTmp->expValueTimeTicksVal); */
/* return (u_char *) & StorageTmp->expValueTimeTicksVal; */
return NULL;
case EXPVALUEINTEGER32VAL:
/* var_len = sizeof(StorageTmp->expValueInteger32Val); */
/* return (u_char *) & StorageTmp->expValueInteger32Val; */
return NULL;
case EXPVALUEIPADDRESSVAL:
/* var_len = sizeof(StorageTmp->expValueIpAddressVal); */
/* return (u_char *) & StorageTmp->expValueIpAddressVal; */
return NULL;
case EXPVALUEOCTETSTRINGVAL:
/* var_len = sizeof(StorageTmp->expValueOctetStringVal); */
/* return (u_char *) & StorageTmp->expValueOctetStringVal; */
return NULL;
case EXPVALUEOIDVAL:
/* var_len = StorageTmp->expValueOidValLen; */
/* return (u_char *) & StorageTmp->expValueOidVal; */
return NULL;
case EXPVALUECOUNTER64VAL:
/* var_len = sizeof(StorageTmp->expValueCounter64Val); */
/* return (u_char *) & StorageTmp->expValueCounter64Val; */
return NULL;
default:
ERROR_MSG("");
return NULL;
}
}
