void
traceRouteResultsTable_cleaner(struct header_complex_index *thestuff)
{
struct header_complex_index *hciptr = NULL;
struct traceRouteResultsTable_data *StorageDel = NULL;
DEBUGMSGTL(("traceRouteResultsTable", "cleanerout "));
for (hciptr = thestuff; hciptr != NULL; hciptr = hciptr->next) {
StorageDel =
header_complex_extract_entry(&traceRouteResultsTableStorage,
hciptr);
if (StorageDel != NULL) {
free(StorageDel->traceRouteCtlOwnerIndex);
StorageDel->traceRouteCtlOwnerIndex = NULL;
free(StorageDel->traceRouteCtlTestName);
StorageDel->traceRouteCtlTestName = NULL;
free(StorageDel->traceRouteResultsIpTgtAddr);
StorageDel->traceRouteResultsIpTgtAddr = NULL;
free(StorageDel->traceRouteResultsLastGoodPath);
StorageDel->traceRouteResultsLastGoodPath = NULL;
free(StorageDel);
StorageDel = NULL;
}
DEBUGMSGTL(("traceRouteResultsTable", "cleaner "));
}
}
/*
* wipe out a single entry
*/
void
header_complex_free_entry(struct header_complex_index *theentry,
HeaderComplexCleaner * cleaner)
{
void *data;
data = header_complex_extract_entry(NULL, theentry);
(*cleaner) (data);
}
void
pingResultsTable_cleaner(struct header_complex_index *thestuff)
{
struct header_complex_index *hciptr;
DEBUGMSGTL(("pingResultsTable", "cleanerout "));
for (hciptr = thestuff; hciptr != NULL; hciptr = hciptr->next) {
header_complex_extract_entry(&pingResultsTableStorage, hciptr);
DEBUGMSGTL(("pingResultsTable", "cleaner "));
}
}
/*
* XXX: this really needs to be done for the target mib entries too.
* But we can only trust that we've added stuff here and we don't want
* to destroy other valid entries in the target tables, so... Don't
* do too many kill -HUPs to your agent as re reading the config file
* will be a slow memory leak in the target mib.
*/
int
notifyTable_unregister_notifications(int major, int minor,
void *serverarg, void *clientarg)
{
struct header_complex_index *hptr, *nhptr;
struct snmpNotifyTable_data *nptr;
for (hptr = snmpNotifyTableStorage; hptr; hptr = nhptr) {
nptr = (struct snmpNotifyTable_data *) hptr->data;
nhptr = hptr->next;
if (nptr->snmpNotifyStorageType == ST_READONLY) {
header_complex_extract_entry(&snmpNotifyTableStorage, hptr);
SNMP_FREE(nptr->snmpNotifyName);
SNMP_FREE(nptr->snmpNotifyTag);
SNMP_FREE(nptr);
}
}
return (0);
}
void
traceRouteHopsTable_cleaner(struct header_complex_index *thestuff)
{
struct header_complex_index *hciptr, *nhciptr;
struct traceRouteHopsTable_data *StorageDel;
DEBUGMSGTL(("traceRouteHopsTable", "cleanerout "));
for (hciptr = thestuff; hciptr; hciptr = nhciptr) {
nhciptr = hciptr->next;
StorageDel = header_complex_extract_entry(&traceRouteHopsTableStorage,
hciptr);
if (StorageDel != NULL) {
free(StorageDel->traceRouteCtlOwnerIndex);
free(StorageDel->traceRouteCtlTestName);
free(StorageDel->traceRouteHopsLastGoodProbe);
free(StorageDel);
}
DEBUGMSGTL(("traceRouteHopsTable", "cleaner "));
}
}
void
lookupResultsTable_cleaner(struct header_complex_index *thestuff)
{
struct header_complex_index *hciptr = NULL;
struct lookupResultsTable_data *StorageDel = NULL;
DEBUGMSGTL(("lookupResultsTable", "cleanerout "));
for (hciptr = thestuff; hciptr != NULL; hciptr = hciptr->next) {
StorageDel =
header_complex_extract_entry(&lookupResultsTableStorage,
hciptr);
if (StorageDel != NULL) {
SNMP_FREE(StorageDel->lookupCtlOwnerIndex);
SNMP_FREE(StorageDel->lookupCtlOperationName);
SNMP_FREE(StorageDel->lookupResultsAddress);
SNMP_FREE(StorageDel);
}
DEBUGMSGTL(("lookupResultsTable", "cleaner "));
}
}
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;
}
memdup((u_char **) & (StorageNew->snmpNotifyName),
vp->val.string, vp->val_len);
if (StorageNew->snmpNotifyName == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
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?
*/
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) {
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;
}
break;
}
return SNMP_ERR_NOERROR;
}
int
write_expObjectEntryStatus(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 expObjectTable_data *StorageTmp = NULL;
static struct expObjectTable_data *StorageNew, *StorageDel;
size_t newlen =
name_len - (sizeof(expObjectTable_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(expObjectTableStorage, NULL,
&name[sizeof(expObjectTable_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 expObjectEntryStatus 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->expObjectEntryStatus == 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 */
snmp_varlist_add_variable(&vars, NULL, 0, ASN_UNSIGNED, NULL, 0); /* expObjectIndex */
if (header_complex_parse_oid
(&
(name
[sizeof(expObjectTable_variables_oid) / sizeof(oid) +
2]), newlen, vars) != SNMPERR_SUCCESS) {
/*
* XXX: free, zero vars
*/
return SNMP_ERR_INCONSISTENTNAME;
}
vp = vars;
StorageNew = create_expObjectTable_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->expObjectIndex = *vp->val.integer;
StorageNew->expObjectEntryStatus = 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)
expObjectTable_add(StorageNew);
/*
* XXX: ack, and if it is NULL?
*/
} else if (set_value != RS_DESTROY) {
/*
* set the flag?
*/
old_value = StorageTmp->expObjectEntryStatus;
StorageTmp->expObjectEntryStatus = *((long *) var_val);
} else {
/*
* destroy... extract it for now
*/
hciptr =
header_complex_find_entry(expObjectTableStorage,
StorageTmp);
StorageDel =
header_complex_extract_entry(&expObjectTableStorage,
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(expObjectTableStorage,
StorageTmp);
StorageDel =
header_complex_extract_entry(&expObjectTableStorage,
hciptr);
/*
* XXX: free it
*/
} else if (StorageDel != NULL) {
/*
* row deletion, so add it again
*/
expObjectTable_add(StorageDel);
} else {
StorageTmp->expObjectEntryStatus = 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->expObjectEntryStatus == RS_CREATEANDGO) {
StorageTmp->expObjectEntryStatus = RS_ACTIVE;
} else if (StorageTmp &&
StorageTmp->expObjectEntryStatus ==
RS_CREATEANDWAIT) {
StorageTmp->expObjectEntryStatus = RS_NOTINSERVICE;
}
}
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
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;
}
snmp_store_needed(NULL);
break;
}
return SNMP_ERR_NOERROR;
}
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_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;
}
