blob: 4e1f4e2bbf5ff828d00234c42269ddd7a98fcbdd [file] [log] [blame]
/*
* TargetParamTable MIB
*
* This file was generated by mib2c and is intended for use as a mib module
* for the ucd-snmp snmpd agent. Edited by Michael Baer
*
* last changed 2/2/99.
*/
#include <net-snmp/net-snmp-config.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#include <stdlib.h>
#include <ctype.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "snmpTargetParamsEntry.h"
#define snmpTargetParamsOIDLen 11 /*This is base+column,
* i.e. everything but index */
oid snmpTargetParamsOID[snmpTargetParamsOIDLen] =
{ 1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 0 };
static struct targetParamTable_struct *aPTable = NULL;
/*
* Utility routines
*/
/*
* TargetParamTable_create creates and returns a pointer
* to a targetParamTable_struct with default values set
*/
struct targetParamTable_struct
*
snmpTargetParamTable_create(void)
{
struct targetParamTable_struct *newEntry;
newEntry = (struct targetParamTable_struct *)
malloc(sizeof(struct targetParamTable_struct));
newEntry->paramName = NULL;
newEntry->mpModel = -1;
newEntry->secModel = -1;
newEntry->secName = NULL;
newEntry->secLevel = -1;
newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
newEntry->rowStatus = SNMP_ROW_NONEXISTENT;
newEntry->next = NULL;
return newEntry;
}
/*
* TargetParamTable_dispose frees the space allocated to a
* targetParamTable_struct
*/
void
snmpTargetParamTable_dispose(struct targetParamTable_struct *reaped)
{
free(reaped->paramName);
free(reaped->secName);
free(reaped);
} /* snmpTargetParamTable_dispose */
/*
* snmpTargetParamTable_addToList adds a targetParamTable_struct
* to a list passed in. The list is assumed to be in a sorted order,
* low to high and this procedure inserts a new struct in the proper
* location. Sorting uses OID values based on paramName. A new equal value
* overwrites a current one.
*/
void
snmpTargetParamTable_addToList(struct targetParamTable_struct *newEntry,
struct targetParamTable_struct **listPtr)
{
static struct targetParamTable_struct *curr_struct, *prev_struct;
int i;
size_t newOIDLen = 0, currOIDLen = 0;
oid newOID[128], currOID[128];
/*
* if the list is empty, add the new entry to the top
*/
if ((prev_struct = curr_struct = *listPtr) == NULL) {
*listPtr = newEntry;
return;
} else {
/*
* get the 'OID' value of the new entry
*/
newOIDLen = strlen(newEntry->paramName);
for (i = 0; i < (int) newOIDLen; i++) {
newOID[i] = newEntry->paramName[i];
}
/*
* search through the list for an equal or greater OID value
*/
while (curr_struct != NULL) {
currOIDLen = strlen(curr_struct->paramName);
for (i = 0; i < (int) currOIDLen; i++) {
currOID[i] = curr_struct->paramName[i];
}
i = snmp_oid_compare(newOID, newOIDLen, currOID, currOIDLen);
if (i == 0) { /* Exact match, overwrite with new struct */
newEntry->next = curr_struct->next;
/*
* if curr_struct is the top of the list
*/
if (*listPtr == curr_struct)
*listPtr = newEntry;
else
prev_struct->next = newEntry;
snmpTargetParamTable_dispose(curr_struct);
return;
} else if (i < 0) { /* Found a greater OID, insert struct in front of it. */
newEntry->next = curr_struct;
/*
* if curr_struct is the top of the list
*/
if (*listPtr == curr_struct)
*listPtr = newEntry;
else
prev_struct->next = newEntry;
return;
}
prev_struct = curr_struct;
curr_struct = curr_struct->next;
}
}
/*
* if we're here, no larger OID was ever found, insert on end of list
*/
prev_struct->next = newEntry;
} /* snmpTargeParamTable_addToList */
void
snmpTargetParamTable_add(struct targetParamTable_struct *newEntry)
{
snmpTargetParamTable_addToList(newEntry, &aPTable);
}
/*
* snmpTargetParamTable_remFromList removes a targetParamTable_struct
* from the list passed in
*/
void
snmpTargetParamTable_remFromList(struct targetParamTable_struct *oldEntry,
struct targetParamTable_struct **listPtr)
{
struct targetParamTable_struct *tptr;
if ((tptr = *listPtr) == NULL)
return;
else if (tptr == oldEntry) {
*listPtr = (*listPtr)->next;
snmpTargetParamTable_dispose(tptr);
return;
} else {
while (tptr->next != NULL) {
if (tptr->next == oldEntry) {
tptr->next = tptr->next->next;
snmpTargetParamTable_dispose(oldEntry);
return;
}
tptr = tptr->next;
}
}
} /* snmpTargetParamTable_remFromList */
/*
* lookup OID in the link list of Table Entries
*/
struct targetParamTable_struct *
search_snmpTargetParamsTable(oid * baseName,
size_t baseNameLen,
oid * name, size_t * length, int exact)
{
static struct targetParamTable_struct *temp_struct;
int i;
size_t myOIDLen = 0;
oid newNum[128];
/*
* lookup entry in p / * Get Current MIB ID
*/
memcpy(newNum, baseName, baseNameLen * sizeof(oid));
for (temp_struct = aPTable; temp_struct != NULL;
temp_struct = temp_struct->next) {
for (i = 0; i < (int) strlen(temp_struct->paramName); i++) {
newNum[baseNameLen + i] = temp_struct->paramName[i];
}
myOIDLen = baseNameLen + strlen(temp_struct->paramName);
i = snmp_oid_compare(name, *length, newNum, myOIDLen);
/*
* Assumes that the linked list sorted by OID, low to high
*/
if ((i == 0 && exact != 0) || (i < 0 && exact == 0)) {
if (exact == 0) {
memcpy(name, newNum, myOIDLen * sizeof(oid));
*length = myOIDLen;
}
return temp_struct;
}
}
return NULL;
} /* search_snmpTargetParamsTable */
/*
* snmpTargetParams_rowStatusCheck is boolean funciton that checks
* the status of a row's values in order to determine whether
* the row should be notReady or notInService
*/
int
snmpTargetParams_rowStatusCheck(struct targetParamTable_struct *entry)
{
if ((entry->mpModel < 0) || (entry->secModel < 0) ||
(entry->secLevel < 0) || (entry->secName == NULL))
return 0;
else
return 1;
} /* snmtpTargetParamTable_rowStatusCheck */
/*
* initialization routines
*/
/*
* this variable defines function callbacks and type return information
* for the snmpTargetAddrEntry mib
*/
struct variable2 snmpTargetParamsEntry_variables[] = {
{SNMPTARGETPARAMSMPMODEL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSMPMODELCOLUMN}},
{SNMPTARGETPARAMSSECURITYMODEL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYMODELCOLUMN}},
{SNMPTARGETPARAMSSECURITYNAME, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYNAMECOLUMN}},
{SNMPTARGETPARAMSSECURITYLEVEL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYLEVELCOLUMN}},
{SNMPTARGETPARAMSSTORAGETYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSTORAGETYPECOLUMN}},
{SNMPTARGETPARAMSROWSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSROWSTATUSCOLUMN}}
};
/*
* now load this mib into the agents mib table
*/
oid snmpTargetParamsEntry_variables_oid[] =
{ 1, 3, 6, 1, 6, 3, 12, 1, 3, 1 };
void
init_snmpTargetParamsEntry(void)
{
aPTable = NULL;
REGISTER_MIB("target/snmpTargetParamsEntry",
snmpTargetParamsEntry_variables, variable2,
snmpTargetParamsEntry_variables_oid);
snmpd_register_config_handler("targetParams",
snmpd_parse_config_targetParams,
(void (*)(void))0, NULL);
/*
* we need to be called back later
*/
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
store_snmpTargetParamsEntry, NULL);
} /* init_snmpTargetParmsEntry */
void
shutdown_snmpTargetParamsEntry(void)
{
while (aPTable)
snmpTargetParamTable_remFromList(aPTable, &aPTable);
}
int
snmpTargetParams_addParamName(struct targetParamTable_struct *entry,
char *cptr)
{
size_t len;
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no param name in config string\n"));
return (0);
} else {
len = strlen(cptr);
/*
* spec check for string 1-32
*/
if (len < 1 || len > 32) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: param name out of range in config string\n"));
return (0);
}
entry->paramName = strdup(cptr);
}
return (1);
}
int
snmpTargetParams_addMPModel(struct targetParamTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no mp model in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: mp model is not digit in config string\n"));
return (0);
}
/*
* spec check MP Model >= 0
*/
else if ((entry->mpModel = (int) strtol(cptr, (char **) NULL, 0)) < 0) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: mp model out of range in config string\n"));
return (0);
}
return (1);
} /* snmpTargetParams_addMPModel */
int
snmpTargetParams_addSecModel(struct targetParamTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no sec model in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: security model is not digit in config string\n"));
return (0);
}
/*
* spec check Sec. Model > 0
*/
else if ((entry->secModel =
(int) strtol(cptr, (char **) NULL, 0)) <= 0) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: security model out of range in config string\n"));
return (0);
}
return (1);
} /* snmpTargetParams_addSecModel */
int
snmpTargetParams_addSecName(struct targetParamTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no security name in config string\n"));
return (0);
} else {
entry->secName = strdup(cptr);
}
return (1);
} /* snmpTargetParams_addSecName */
int
snmpTargetParams_addSecLevel(struct targetParamTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no security level in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: security level is not digit in config string\n"));
return (0);
}
/*
* no spec range check, but noAuthNoPriv is 1 so...
*/
else if ((entry->secLevel =
(int) strtol(cptr, (char **) NULL, 0)) <= 0) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: security level is not greater than 0 in config string\n"));
return (0);
}
return (1);
} /* snmpTargetParams_addSecLevel */
int
snmpTargetParams_addStorageType(struct targetParamTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no storage type in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: storage type is not digit in config string\n"));
return (0);
}
/*
* check that storage type is a possible value
*/
else if (((entry->storageType = (int) strtol(cptr, (char **) NULL, 0))
!= SNMP_STORAGE_OTHER) &&
(entry->storageType != SNMP_STORAGE_VOLATILE) &&
(entry->storageType != SNMP_STORAGE_NONVOLATILE) &&
(entry->storageType != SNMP_STORAGE_PERMANENT) &&
(entry->storageType != SNMP_STORAGE_READONLY)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: storage type is not a valid value of"));
DEBUGMSG(("snmpTargetParamsEntry",
" other(%d), volatile(%d), nonvolatile(%d), permanent(%d), or ",
SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
SNMP_STORAGE_NONVOLATILE, SNMP_STORAGE_PERMANENT));
DEBUGMSGTL(("snmpTargetParamsEntry",
"readonly(%d) in config string.\n",
SNMP_STORAGE_READONLY));
return (0);
}
return (1);
} /* snmpTargetParams_addStorageType */
int
snmpTargetParams_addRowStatus(struct targetParamTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: no row status in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargeParamsEntry: row status is not digit in config string\n"));
return (0);
}
/*
* check that row status is a valid value
*/
else if (((entry->rowStatus = (int) strtol(cptr, (char **) NULL, 0))
!= SNMP_ROW_ACTIVE) &&
(entry->rowStatus != SNMP_ROW_NOTINSERVICE) &&
(entry->rowStatus != SNMP_ROW_NOTREADY)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"ERROR snmpTargetParamsEntry: Row Status is not a valid value of "));
DEBUGMSG(("snmpTargetParamsEntry",
"active(%d), notinservice(%d), or notready(%d) in config string.\n",
SNMP_ROW_ACTIVE, SNMP_ROW_NOTINSERVICE,
SNMP_ROW_NOTREADY));
return (0);
}
return (1);
} /* snmpTargetParams_addRowStatus */
/*
* timestamp the current entry's modification time
*/
void
update_timestamp(struct targetParamTable_struct *temp_struct)
{
temp_struct->updateTime = time(NULL);
}
void
snmpd_parse_config_targetParams(const char *token, char *char_ptr)
{
char *cptr = char_ptr, buff[1024];
struct targetParamTable_struct *newEntry;
newEntry = snmpTargetParamTable_create();
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addParamName(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addMPModel(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addSecModel(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addSecName(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addSecLevel(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addStorageType(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
cptr = copy_nword(cptr, buff, sizeof(buff));
if (snmpTargetParams_addRowStatus(newEntry, buff) == 0) {
snmpTargetParamTable_dispose(newEntry);
return;
}
DEBUGMSGTL(("snmpTargetParamsEntry",
"snmp_parse_config_targetParams, read: %s %d %d %s %d %d %d\n",
newEntry->paramName, newEntry->mpModel, newEntry->secModel,
newEntry->secName, newEntry->secLevel, newEntry->storageType,
newEntry->rowStatus));
update_timestamp(newEntry);
snmpTargetParamTable_addToList(newEntry, &aPTable);
} /* snmpd_parse_config_target */
/*
* shutdown routines
*/
/*
* store_snmpTargetParamsEntry handles the presistent storage proccess
* for this MIB table. It writes out all the non-volatile rows
* to permanent storage on a shutdown
*/
int
store_snmpTargetParamsEntry(int majorID, int minorID, void *serverarg,
void *clientarg)
{
struct targetParamTable_struct *curr_struct;
char line[1024];
strcpy(line, "");
if ((curr_struct = aPTable) != NULL) {
while (curr_struct != NULL) {
if ((curr_struct->storageType == SNMP_STORAGE_NONVOLATILE ||
curr_struct->storageType == SNMP_STORAGE_PERMANENT)
&&
(curr_struct->rowStatus == SNMP_ROW_ACTIVE ||
curr_struct->rowStatus == SNMP_ROW_NOTINSERVICE)) {
snprintf(line, sizeof(line),
"targetParams %s %i %i %s %i %i %i\n",
curr_struct->paramName, curr_struct->mpModel,
curr_struct->secModel, curr_struct->secName,
curr_struct->secLevel, curr_struct->storageType,
curr_struct->rowStatus);
line[ sizeof(line)-1 ] = 0;
/*
* store to file
*/
snmpd_store_config(line);
}
curr_struct = curr_struct->next;
}
}
return SNMPERR_SUCCESS;
} /* store_snmpTargetParmsEntry */
/*
* MIB table access routines
*/
u_char *
var_snmpTargetParamsEntry(struct variable * vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
/*
* variables we may use later
*/
static long long_ret;
static unsigned char string[1500];
struct targetParamTable_struct *temp_struct;
switch (vp->magic) {
#ifndef NETSNMP_NO_WRITE_SUPPORT
case SNMPTARGETPARAMSMPMODEL:
*write_method = write_snmpTargetParamsMPModel;
break;
case SNMPTARGETPARAMSSECURITYMODEL:
*write_method = write_snmpTargetParamsSecModel;
break;
case SNMPTARGETPARAMSSECURITYNAME:
*write_method = write_snmpTargetParamsSecName;
break;
case SNMPTARGETPARAMSSECURITYLEVEL:
*write_method = write_snmpTargetParamsSecLevel;
break;
case SNMPTARGETPARAMSSTORAGETYPE:
*write_method = write_snmpTargetParamsStorageType;
break;
case SNMPTARGETPARAMSROWSTATUS:
*write_method = write_snmpTargetParamsRowStatus;
break;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
default:
*write_method = NULL;
}
/* assume an integer and change later if not */
*var_len = sizeof(long_ret);
/*
* look for OID in current table
*/
if ((temp_struct = search_snmpTargetParamsTable(vp->name, vp->namelen,
name, length,
exact)) == NULL) {
return NULL;
}
/*
* We found what we were looking for, either the next OID or the exact OID
*/
/*
* this is where we do the value assignments for the mib results.
*/
switch (vp->magic) {
case SNMPTARGETPARAMSMPMODEL:
/*
* if unset value, (i.e. new row)
*/
if (temp_struct->mpModel == -1)
return NULL;
long_ret = temp_struct->mpModel;
return (unsigned char *) &long_ret;
case SNMPTARGETPARAMSSECURITYMODEL:
/*
* if unset value, (i.e. new row)
*/
if (temp_struct->secModel == -1)
return NULL;
long_ret = temp_struct->secModel;
return (unsigned char *) &long_ret;
case SNMPTARGETPARAMSSECURITYNAME:
/*
* if unset value, (i.e. new row)
*/
if (temp_struct->secName == NULL)
return NULL;
/*
* including null character.
*/
memcpy(string, temp_struct->secName, strlen(temp_struct->secName));
string[strlen(temp_struct->secName)] = '\0';
*var_len = strlen(temp_struct->secName);
return (unsigned char *) string;
case SNMPTARGETPARAMSSECURITYLEVEL:
/*
* if unset value, (i.e. new row)
*/
if (temp_struct->secLevel == -1)
return NULL;
long_ret = temp_struct->secLevel;
return (unsigned char *) &long_ret;
case SNMPTARGETPARAMSSTORAGETYPE:
long_ret = temp_struct->storageType;
return (unsigned char *) &long_ret;
case SNMPTARGETPARAMSROWSTATUS:
long_ret = temp_struct->rowStatus;
return (unsigned char *) &long_ret;
default:
DEBUGMSGTL(("snmpd",
"unknown sub-id %d in var_snmpTargetParamsEntry\n",
vp->magic));
}
return NULL;
} /* var_snmpTargetParamsEntry */
#ifndef NETSNMP_NO_WRITE_SUPPORT
/*
* Assign a value to the mpModel variable.
*/
int
write_snmpTargetParamsMPModel(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP, oid * name, size_t name_len)
{
long long_ret = *((long *) var_val);
static long old_mp;
struct targetParamTable_struct *params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsMPModel: not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsMPModel: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (long_ret < 0) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsMPModel: MP Model out of range\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
} else if (action == RESERVE2) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSMPMODELCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsMPModel: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
/*
* Row exists, check if it is changeable.
*/
if (params->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamMPModel: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
/*
* Check if row is active.
*/
if (params->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsMPModel: this change not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_mp = params->mpModel;
params->mpModel = long_ret;
if (params->rowStatus == SNMP_ROW_NOTREADY &&
snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSMPMODELCOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
update_timestamp(params);
}
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSMPMODELCOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
if (params->storageType != SNMP_STORAGE_READONLY
&& params->rowStatus != SNMP_ROW_ACTIVE) {
params->mpModel = old_mp;
if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
!snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetParamsMPModel */
/*
* Assign a value to the secModel variable.
*/
int
write_snmpTargetParamsSecModel(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP, oid * name, size_t name_len)
{
long long_ret = *((long *) var_val);
static long old_sec;
struct targetParamTable_struct *params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecModel: not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecModel: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (long_ret <= 0) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecModel: secModel out of range\n"));
return SNMP_ERR_WRONGVALUE;
}
if (find_sec_mod(long_ret) == NULL && long_ret >= 3) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecModel: secModel %ld unsupported\n",
long_ret));
return SNMP_ERR_INCONSISTENTVALUE;
}
} else if (action == RESERVE2) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYMODELCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecModel: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
/*
* Row exists, check if it is changeable.
*/
if (params->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamSecModel: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
/*
* Check if row is active.
*/
if (params->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecModel: this change not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_sec = params->secModel;
params->secModel = long_ret;
if (params->rowStatus == SNMP_ROW_NOTREADY &&
snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYMODELCOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
update_timestamp(params);
}
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYMODELCOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
if (params->storageType != SNMP_STORAGE_READONLY
&& params->rowStatus != SNMP_ROW_ACTIVE) {
params->secModel = old_sec;
if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
!snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetParamsSecModel */
/*
* Assign a value to the SecLevel variable.
*/
int
write_snmpTargetParamsSecLevel(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP, oid * name, size_t name_len)
{
long long_ret = *((long *) var_val);
static long old_level;
struct targetParamTable_struct *params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecLevel: not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecLevel: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (long_ret <= 0 || long_ret > 3) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecLevel: security level is not noAuthNoPriv(1), authNopriv(2) or authPriv(3)\n"));
return SNMP_ERR_WRONGVALUE;
}
} else if (action == RESERVE2) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecLevel: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
/*
* Row exists, check if it is changeable.
*/
if (params->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamSecLevel: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
/*
* Check if row is active.
*/
if (params->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecLevel: this change not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_level = params->secLevel;
params->secLevel = long_ret;
if (params->rowStatus == SNMP_ROW_NOTREADY &&
snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
update_timestamp(params);
}
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
if (params->storageType != SNMP_STORAGE_READONLY
&& params->rowStatus != SNMP_ROW_ACTIVE) {
params->secLevel = old_level;
if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
!snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetParamsSecLevel */
/*
* Assign a value to the storageType variable.
*/
int
write_snmpTargetParamsStorageType(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP,
oid * name, size_t name_len)
{
long long_ret = *((long *) var_val);
static long old_st;
struct targetParamTable_struct *params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsStorageType: not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsStorageType: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (long_ret != SNMP_STORAGE_OTHER &&
long_ret != SNMP_STORAGE_VOLATILE &&
long_ret != SNMP_STORAGE_NONVOLATILE) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsStorageType: attempted storage type not a valid"));
DEBUGMSG(("snmpTargetParamsEntry",
" value of other(%d), volatile(%d), or nonvolatile(%d)\n",
SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
SNMP_STORAGE_NONVOLATILE));
return SNMP_ERR_WRONGVALUE;
}
} else if (action == RESERVE2) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSTORAGETYPECOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsStorageType: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
/*
* Row exists, check if it is changeable.
*/
if (params->storageType == SNMP_STORAGE_READONLY ||
params->storageType == SNMP_STORAGE_PERMANENT) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsStorageType: row has unchangeable storage status: %d\n",
params->storageType));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_st = params->storageType;
params->storageType = long_ret;
}
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSTORAGETYPECOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
if (params->storageType != SNMP_STORAGE_READONLY
&& params->storageType != SNMP_STORAGE_PERMANENT) {
params->storageType = old_st;
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetParamsStorageType */
/*
* Assign a value to the secName variable.
*/
int
write_snmpTargetParamsSecName(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 *old_name;
struct targetParamTable_struct *params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_OCTET_STR) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecName: not ASN_OCTET_STR\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > 255) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecName: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
} else if (action == RESERVE2) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYNAMECOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params == NULL) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecName: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
/*
* Row exists, check if it is changeable.
*/
if (params->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamSecName: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
/*
* Check if row is active.
*/
if (params->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsSecName: this change not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_name = params->secName;
params->secName = (char *) malloc(var_val_len + 1);
if (params->secName == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
memcpy(params->secName, var_val, var_val_len);
params->secName[var_val_len] = '\0';
if (params->rowStatus == SNMP_ROW_NOTREADY &&
snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYNAMECOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
update_timestamp(params);
SNMP_FREE(old_name);
old_name = NULL;
}
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSSECURITYNAMECOLUMN;
if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len,
1)) != NULL) {
if (params->storageType != SNMP_STORAGE_READONLY
&& params->rowStatus != SNMP_ROW_ACTIVE) {
SNMP_FREE(params->secName);
params->secName = old_name;
if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
!snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetParamsSecName */
/*
* snmpTargeParams_createNewRow is called from write_snmpTargetParamsRowStatus
* when a new row is required. It creates a new row with
* the index of the passed in 'name' (i.e. full index OID) and
* adds it to the linked list. 'name' should be the full OID of the new index.
* It passes back 0 if unsuccessfull.
*/
int
snmpTargetParams_createNewRow(oid * name, size_t name_len)
{
int pNameLen, i;
struct targetParamTable_struct *temp_struct;
/*
* setup a new snmpTargetParamTable structure and add it to the list
*/
pNameLen = name_len - snmpTargetParamsOIDLen;
if (pNameLen > 0) {
temp_struct = snmpTargetParamTable_create();
temp_struct->paramName = (char *) malloc(pNameLen + 1);
for (i = 0; i < pNameLen; i++) {
temp_struct->paramName[i] =
(char) name[i + snmpTargetParamsOIDLen];
}
temp_struct->paramName[pNameLen] = '\0';
temp_struct->rowStatus = SNMP_ROW_NOTREADY;
update_timestamp(temp_struct);
snmpTargetParamTable_addToList(temp_struct, &aPTable);
return 1;
}
return 0;
} /* snmpTargetParams_createNewRow */
/*
* Assign a value to the Row Status variable
*/
int
write_snmpTargetParamsRowStatus(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 long value;
struct targetParamTable_struct *params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsRowStatus not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"write to snmpTargetParamsRowStatus: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
value = *((long *) var_val);
if (value == SNMP_ROW_NOTREADY || value < 1 || value > 6) {
return SNMP_ERR_WRONGVALUE;
}
/*
* Check index value is reasonable.
*/
if (name_len < snmpTargetParamsOIDLen + 1 ||
name_len > snmpTargetParamsOIDLen + 32) {
DEBUGMSGTL(("snmpTargetParamsEntry", "bad index length %d\n",
(int)(name_len - snmpTargetParamsOIDLen)));
return SNMP_ERR_NOCREATION;
}
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSROWSTATUSCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params != NULL) {
if (value == SNMP_ROW_CREATEANDGO
|| value == SNMP_ROW_CREATEANDWAIT) {
value = SNMP_ROW_NOTREADY;
return SNMP_ERR_INCONSISTENTVALUE;
}
if (params->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
if (params->storageType == SNMP_STORAGE_PERMANENT) {
if (value == SNMP_ROW_DESTROY) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"unable to destroy permanent row\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
}
} else {
if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
return SNMP_ERR_INCONSISTENTVALUE;
}
if (value == SNMP_ROW_CREATEANDGO
|| value == SNMP_ROW_CREATEANDWAIT) {
if (snmpTargetParams_createNewRow(name, name_len) == 0) {
DEBUGMSGTL(("snmpTargetParamsEntry",
"couldn't malloc() new row\n"));
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
}
}
} else if (action == ACTION) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSROWSTATUSCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params != NULL) {
if (value == SNMP_ROW_CREATEANDGO) {
/*
* Check whether all the required objects have been set.
*/
if (snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_ACTIVE;
} else {
params->rowStatus = SNMP_ROW_NOTREADY;
}
} else if (value == SNMP_ROW_CREATEANDWAIT) {
/*
* Check whether all the required objects have been set.
*/
if (snmpTargetParams_rowStatusCheck(params)) {
params->rowStatus = SNMP_ROW_NOTINSERVICE;
} else {
params->rowStatus = SNMP_ROW_NOTREADY;
}
} else if (value == SNMP_ROW_ACTIVE) {
if (params->rowStatus == SNMP_ROW_NOTINSERVICE) {
params->rowStatus = SNMP_ROW_ACTIVE;
} else if (params->rowStatus == SNMP_ROW_NOTREADY) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else if (value == SNMP_ROW_NOTINSERVICE) {
if (params->rowStatus == SNMP_ROW_ACTIVE) {
params->rowStatus = SNMP_ROW_NOTINSERVICE;
} else if (params->rowStatus == SNMP_ROW_NOTREADY) {
return SNMP_ERR_INCONSISTENTVALUE;
}
}
}
} else if (action == COMMIT) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSROWSTATUSCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (params != NULL) {
if (value == SNMP_ROW_DESTROY) {
snmpTargetParamTable_remFromList(params, &aPTable);
}
if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
update_timestamp(params);
}
}
snmp_store_needed(NULL);
} else if (action == UNDO || action == FREE) {
snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
SNMPTARGETPARAMSROWSTATUSCOLUMN;
params = search_snmpTargetParamsTable(snmpTargetParamsOID,
snmpTargetParamsOIDLen,
name, &name_len, 1);
if (value == SNMP_ROW_CREATEANDGO
|| value == SNMP_ROW_CREATEANDWAIT) {
if (params != NULL) {
snmpTargetParamTable_remFromList(params, &aPTable);
}
}
}
return SNMP_ERR_NOERROR;
}
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
struct targetParamTable_struct *
get_paramEntry(char *name)
{
static struct targetParamTable_struct *ptr;
for (ptr = aPTable; ptr; ptr = ptr->next) {
if (strcmp(ptr->paramName, name) == 0) {
return ptr;
}
}
return NULL;
}