blob: b1eb00acfd6509a9d584c72d72c18cccc325e6b8 [file] [log] [blame]
/*
* snmpTargetAddrEntry 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 "snmpTargetAddrEntry.h"
#include "util_funcs/header_generic.h"
#define snmpTargetAddrOIDLen 11 /*This is base+column,
* i.e. everything but index */
static oid snmpTargetAddrOID[snmpTargetAddrOIDLen] =
{ 1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 0 };
static unsigned long snmpTargetSpinLock = 0;
static struct targetAddrTable_struct *aAddrTable = NULL;
static int
store_snmpTargetAddrEntry(int majorID, int minorID, void *serverarg,
void *clientarg);
/*
* Utility routines
*/
struct targetAddrTable_struct *
get_addrTable(void)
{
return aAddrTable;
}
struct targetAddrTable_struct *
get_addrForName2(const char *name, unsigned char nameLen)
{
struct targetAddrTable_struct *ptr;
for (ptr = aAddrTable; ptr != NULL; ptr = ptr->next) {
if (ptr->nameLen == nameLen &&
memcmp(ptr->nameData, name, nameLen) == 0)
return ptr;
}
return NULL;
}
/*
* TargetAddrTable_create creates and returns a pointer
* to a targetAddrTable_struct with default values set
*/
struct targetAddrTable_struct *snmpTargetAddrTable_create(void)
{
struct targetAddrTable_struct *newEntry;
newEntry = malloc(sizeof(*newEntry));
if (newEntry) {
newEntry->nameData = NULL;
newEntry->nameLen = 0;
newEntry->tDomainLen = 0;
newEntry->tAddress = NULL;
newEntry->timeout = 1500;
newEntry->retryCount = 3;
newEntry->tagList = strdup("");
newEntry->params = NULL;
newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
newEntry->rowStatus = SNMP_ROW_NONEXISTENT;
newEntry->sess = NULL;
newEntry->next = NULL;
}
return newEntry;
} /* snmpTargetAddrTable_create */
/*
* TargetAddrTable_dispose frees the space allocated to a
* targetAddrTable_struct
*/
void
snmpTargetAddrTable_dispose(struct targetAddrTable_struct *reaped)
{
if (reaped->sess)
snmp_close(reaped->sess);
else
SNMP_FREE(reaped->tAddress);
SNMP_FREE(reaped->nameData);
SNMP_FREE(reaped->tagList);
SNMP_FREE(reaped->params);
SNMP_FREE(reaped);
} /* snmpTargetAddrTable_dispose */
/*
* snmpTargetAddrTable_addToList adds a targetAddrTable_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 name. A new equal value
* overwrites a current one.
*/
void
snmpTargetAddrTable_addToList(struct targetAddrTable_struct *newEntry,
struct targetAddrTable_struct **listPtr)
{
static struct targetAddrTable_struct *curr_struct, *prev_struct;
int i;
/*
* if the list is empty, add the new entry to the top
*/
if ((prev_struct = curr_struct = *listPtr) == NULL) {
*listPtr = newEntry;
return;
} else {
/*
* search through the list for an equal or greater OID value
*/
while (curr_struct != NULL) {
i = memcmp(newEntry->nameData, curr_struct->nameData,
newEntry->nameLen < curr_struct->nameLen ?
newEntry->nameLen : curr_struct->nameLen);
if (i == 0) {
if (newEntry->nameLen < curr_struct->nameLen)
i = -1;
else if (newEntry->nameLen > curr_struct->nameLen)
i = 1;
}
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;
snmpTargetAddrTable_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;
} /* snmpTargeAddrTable_addToList */
void
snmpTargetAddrTable_add(struct targetAddrTable_struct *newEntry)
{
snmpTargetAddrTable_addToList(newEntry, &aAddrTable);
}
/*
* snmpTargetAddrTable_remFromList removes a targetAddrTable_struct
* from the list passed in
*/
void
snmpTargetAddrTable_remFromList(struct targetAddrTable_struct *oldEntry,
struct targetAddrTable_struct **listPtr)
{
struct targetAddrTable_struct *tptr;
if ((tptr = *listPtr) == NULL)
return;
else if (tptr == oldEntry) {
*listPtr = (*listPtr)->next;
snmpTargetAddrTable_dispose(tptr);
return;
} else {
while (tptr->next != NULL) {
if (tptr->next == oldEntry) {
tptr->next = tptr->next->next;
snmpTargetAddrTable_dispose(oldEntry);
return;
}
tptr = tptr->next;
}
}
} /* snmpTargetAddrTable_remFromList */
/*
* lookup OID in the link list of Addr Table Entries
*/
struct targetAddrTable_struct *
search_snmpTargetAddrTable(oid * baseName,
size_t baseNameLen,
oid * name, size_t * length, int exact)
{
static struct targetAddrTable_struct *temp_struct;
int i;
size_t myOIDLen = 0;
oid newNum[128];
/*
* lookup entry in addrTable linked list, Get Current MIB ID
*/
memcpy(newNum, baseName, baseNameLen * sizeof(oid));
for (temp_struct = aAddrTable; temp_struct != NULL;
temp_struct = temp_struct->next) {
for (i = 0; i < temp_struct->nameLen; i++) {
newNum[baseNameLen + i] = (unsigned char)temp_struct->nameData[i];
}
myOIDLen = baseNameLen + temp_struct->nameLen;
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_snmpTargetAddrTable */
/*
* snmpTargetAddr_rowStatusCheck is boolean function that checks
* the status of a row's values in order to determine whether
* the row should be notReady or notInService.
*/
static int
snmpTargetAddr_rowStatusCheck(const struct targetAddrTable_struct *entry)
{
return entry->tDomainLen && entry->tAddress && entry->params;
} /* snmtpTargetAddrTable_rowStatusCheck */
/*
* Init routines
*/
/*
* this variable defines function callbacks and type return information
* for the snmpTargetAddrEntry mib
*/
static const struct variable2 snmpTargetAddrEntry_variables[] = {
{SNMPTARGETADDRTDOMAIN, ASN_OBJECT_ID, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTDOMAINCOLUMN}},
{SNMPTARGETADDRTADDRESS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTADDRESSCOLUMN}},
{SNMPTARGETADDRTIMEOUT, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTIMEOUTCOLUMN}},
{SNMPTARGETADDRRETRYCOUNT, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRRETRYCOUNTCOLUMN}},
{SNMPTARGETADDRTAGLIST, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTAGLISTCOLUMN}},
{SNMPTARGETADDRPARAMS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRPARAMSCOLUMN}},
{SNMPTARGETADDRSTORAGETYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRSTORAGETYPECOLUMN}},
{SNMPTARGETADDRROWSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRROWSTATUSCOLUMN}},
};
static const struct variable2 snmpTargetSpinLock_var[] = {
{SNMPTARGETSPINLOCK, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
var_targetSpinLock, 1, {1}}
};
static const oid snmpTargetSpinLock_oid[] = { 1, 3, 6, 1, 6, 3, 12, 1 };
/*
* now load this mib into the agents mib table
*/
static const oid snmpTargetAddrEntry_variables_oid[] =
{ 1, 3, 6, 1, 6, 3, 12, 1, 2, 1 };
void
init_snmpTargetAddrEntry(void)
{
aAddrTable = NULL;
DEBUGMSGTL(("snmpTargetAddrEntry", "init\n"));
REGISTER_MIB("target/snmpTargetAddrEntry",
snmpTargetAddrEntry_variables, variable2,
snmpTargetAddrEntry_variables_oid);
REGISTER_MIB("target/snmpTargetSpinLock", snmpTargetSpinLock_var,
variable2, snmpTargetSpinLock_oid);
snmpd_register_config_handler("targetAddr",
snmpd_parse_config_targetAddr,
(void (*)(void))0, NULL);
/*
* we need to be called back later
*/
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
store_snmpTargetAddrEntry, NULL);
} /* init_snmpTargetAddrEntry */
void
shutdown_snmpTargetAddrEntry(void)
{
struct targetAddrTable_struct *ptr;
struct targetAddrTable_struct *next;
for (ptr = aAddrTable; ptr; ptr = next) {
next = ptr->next;
snmpTargetAddrTable_dispose(ptr);
}
aAddrTable = NULL;
snmp_unregister_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
store_snmpTargetAddrEntry, NULL, FALSE);
}
int
snmpTargetAddr_addTDomain(struct targetAddrTable_struct *entry, char *cptr)
{
size_t len = 128;
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no tDomain in config string\n"));
return (0);
}
if (!read_objid(cptr, entry->tDomain, &len)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: tDomain unreadable in config string\n"));
return (0);
}
/*
* spec check for oid 1-128
*/
if (len < 1 || len > 128) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: tDomain out of range in config string\n"));
return (0);
}
entry->tDomainLen = len;
return (1);
} /* snmpTargetAddr_addTDomain */
int
snmpTargetAddr_addTAddress(struct targetAddrTable_struct *entry,
char *cptr, size_t len)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no tAddress in config string\n"));
return (0);
} else {
/*
* spec check for string 1-32
*/
/*
* if (len < 1 || len > 32) {
* DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: name out of range in config string\n"));
* return(0);
* }
*/
SNMP_FREE(entry->tAddress);
entry->tAddress = (u_char *) malloc(len);
entry->tAddressLen = len;
memcpy(entry->tAddress, cptr, len);
}
return (1);
} /* snmpTargetAddr_addTAddress */
int
snmpTargetAddr_addTimeout(struct targetAddrTable_struct *entry, char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetParamsEntry: no Timeout in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargeParamsEntry: Timeout is not a digit in config string\n"));
return (0);
}
/*
* check Timeout >= 0
*/
else if ((entry->timeout = (int) strtol(cptr, (char **) NULL, 0)) < 0) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargeParamsEntry: Timeout out of range in config string\n"));
return (0);
}
return (1);
} /* snmpTargetAddr_addTimeout */
int
snmpTargetAddr_addRetryCount(struct targetAddrTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetParamsEntry: no Retry Count in config string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargeParamsEntry: Retry Count is not a digit in config string\n"));
return (0);
}
/*
* spec check 0..255
*/
else {
entry->retryCount = (int) strtol(cptr, (char **) NULL, 0);
if ((entry->retryCount < 0) || (entry->retryCount > 255)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargeParamsEntry: Retry Count is out of range in config string\n"));
return (0);
}
}
return (1);
} /* snmpTargetAddr_addRetryCount */
int
snmpTargetAddr_addTagList(struct targetAddrTable_struct *entry, char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no tag list in config string\n"));
return (0);
} else {
size_t len = strlen(cptr);
/*
* spec check for string 0-255
*/
if (len > 255) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: tag list out of range in config string\n"));
return (0);
}
SNMP_FREE(entry->tagList);
entry->tagList = strdup(cptr);
}
return (1);
} /* snmpTargetAddr_addTagList */
int
snmpTargetAddr_addParams(struct targetAddrTable_struct *entry, char *cptr)
{
size_t len;
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no params in config string\n"));
return (0);
} else {
len = strlen(cptr);
/*
* spec check for string 1-32
*/
if (len < 1 || len > 32) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: params out of range in config string\n"));
return (0);
}
entry->params = strdup(cptr);
}
return (1);
} /* snmpTargetAddr_addParams */
int
snmpTargetAddr_addStorageType(struct targetAddrTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no storage type in config "
"string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: storage type is not a 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(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: storage type not a valid "
"value of other(%d), volatile(%d), nonvolatile(%d), "
"permanent(%d), or readonly(%d) in config string.\n",
SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
SNMP_STORAGE_NONVOLATILE, SNMP_STORAGE_PERMANENT,
SNMP_STORAGE_READONLY));
return (0);
}
return (1);
} /* snmpTargetAddr_addStorageType */
int
snmpTargetAddr_addRowStatus(struct targetAddrTable_struct *entry,
char *cptr)
{
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no Row Status in config "
"string\n"));
return (0);
} else if (!(isdigit((unsigned char)(*cptr)))) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: Row Status is not a 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(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: Row Status is not a valid "
"value of active(%d), notinservice(%d), or notready(%d) "
"in config string.\n",
SNMP_ROW_ACTIVE, SNMP_ROW_NOTINSERVICE, SNMP_ROW_NOTREADY));
return (0);
}
return (1);
} /* snmpTargetAddr_addRowStatus */
void
snmpd_parse_config_targetAddr(const char *token, char *char_ptr)
{
const char *cptr = char_ptr;
char buff[1024], *bptr;
struct targetAddrTable_struct *newEntry;
int i;
size_t bufl;
newEntry = snmpTargetAddrTable_create();
cptr = skip_white_const(cptr);
if (cptr == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no name in config string\n"));
snmpTargetAddrTable_dispose(newEntry);
return;
}
bufl = 0;
cptr = read_config_read_octet_string_const(cptr,
(u_char**)&newEntry->nameData,
&bufl);
if (bufl < 1 || bufl > 32) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: name out of range in config "
"string\n"));
snmpTargetAddrTable_dispose(newEntry);
return;
}
newEntry->nameLen = bufl;
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addTDomain(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr =
read_config_read_octet_string_const(cptr,
(u_char **) & newEntry->tAddress,
&newEntry->tAddressLen);
if (!cptr || !(newEntry->tAddress)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"ERROR snmpTargetAddrEntry: no TAddress in config string\n"));
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addTimeout(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addRetryCount(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addTagList(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addParams(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addStorageType(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
cptr = copy_nword_const(cptr, buff, sizeof(buff));
if (snmpTargetAddr_addRowStatus(newEntry, buff) == 0) {
snmpTargetAddrTable_dispose(newEntry);
return;
}
bptr = buff;
bptr += sprintf(bptr, "snmp_parse_config_targetAddr, read: ");
bptr = read_config_save_octet_string(bptr, (u_char*)newEntry->nameData,
newEntry->nameLen);
*bptr++ = '\n';
for (i = 0; i < newEntry->tDomainLen; i++) {
bptr += snprintf(bptr, buff + sizeof(buff) - bptr,
".%d", (int) newEntry->tDomain[i]);
}
bptr += snprintf(bptr, buff + sizeof(buff) - bptr,
" %s %d %d %s %s %d %d\n",
newEntry->tAddress, newEntry->timeout,
newEntry->retryCount, newEntry->tagList,
newEntry->params, newEntry->storageType,
newEntry->rowStatus);
buff[ sizeof(buff) - 1 ] = 0;
DEBUGMSGTL(("snmpTargetAddrEntry", "%s", buff));
snmpTargetAddrTable_addToList(newEntry, &aAddrTable);
} /* snmpd_parse_config_target */
/*
* Shutdown routines
*/
/*
* store_snmpTargetAddrEntry handles the persistent storage proccess
* for this MIB table. It writes out all the non-volatile rows
* to permanent storage on a shutdown
*/
static int
store_snmpTargetAddrEntry(int majorID, int minorID, void *serverarg,
void *clientarg)
{
const struct targetAddrTable_struct *curr_struct;
char line[1024], *cur, *ep = line + sizeof(line);
int i;
curr_struct = aAddrTable;
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)) {
cur = line + snprintf(line, sizeof(line), "targetAddr ");
cur = read_config_save_octet_string(
cur, (u_char*)curr_struct->nameData, curr_struct->nameLen);
*cur++ = ' ';
for (i = 0; i < curr_struct->tDomainLen; i++) {
cur += snprintf(cur, ep - cur, ".%i",
(int) curr_struct->tDomain[i]);
}
*cur++ = ' ';
cur = read_config_save_octet_string(
cur, curr_struct->tAddress, curr_struct->tAddressLen);
cur += snprintf(cur, ep - cur, " %i %i \"%s\" %s %i %i",
curr_struct->timeout,
curr_struct->retryCount, curr_struct->tagList,
curr_struct->params, 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_snmpTargetAddrEntry */
/*
* MIB table access routines
*/
u_char *
var_snmpTargetAddrEntry(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 char string[1500];
static oid objid[128];
struct targetAddrTable_struct *temp_struct;
int i = 0;
/*
* Set up write_method first, in case we return NULL before getting to the
* switch (vp->magic) below. In some of these cases, we still want to call
* the appropriate write_method, if only to have it return the appropriate
* error.
*/
switch (vp->magic) {
#ifndef NETSNMP_NO_WRITE_SUPPORT
case SNMPTARGETADDRTDOMAIN:
*write_method = write_snmpTargetAddrTDomain;
break;
case SNMPTARGETADDRTADDRESS:
*write_method = write_snmpTargetAddrTAddress;
break;
case SNMPTARGETADDRRETRYCOUNT:
*write_method = write_snmpTargetAddrRetryCount;
break;
case SNMPTARGETADDRTIMEOUT:
*write_method = write_snmpTargetAddrTimeout;
break;
case SNMPTARGETADDRTAGLIST:
*write_method = write_snmpTargetAddrTagList;
break;
case SNMPTARGETADDRPARAMS:
*write_method = write_snmpTargetAddrParams;
break;
case SNMPTARGETADDRSTORAGETYPE:
*write_method = write_snmpTargetAddrStorageType;
break;
case SNMPTARGETADDRROWSTATUS:
*write_method = write_snmpTargetAddrRowStatus;
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_snmpTargetAddrTable(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 SNMPTARGETADDRTDOMAIN:
if (temp_struct->tDomainLen <= 0) {
return NULL;
} else {
for (i = 0; i < temp_struct->tDomainLen; i++) {
objid[i] = temp_struct->tDomain[i];
}
*var_len = temp_struct->tDomainLen * sizeof(oid);
}
return (unsigned char *) objid;
case SNMPTARGETADDRTADDRESS:
if (temp_struct->tAddress == NULL)
return NULL;
*var_len = temp_struct->tAddressLen;
return (unsigned char *) temp_struct->tAddress;
case SNMPTARGETADDRTIMEOUT:
long_ret = temp_struct->timeout;
return (unsigned char *) &long_ret;
case SNMPTARGETADDRRETRYCOUNT:
long_ret = temp_struct->retryCount;
return (unsigned char *) &long_ret;
case SNMPTARGETADDRTAGLIST:
if (temp_struct->tagList != NULL) {
strlcpy(string, temp_struct->tagList, sizeof(string));
*var_len = strlen(string);
return (unsigned char *) string;
} else {
return NULL;
}
case SNMPTARGETADDRPARAMS:
if (temp_struct->params == NULL)
return NULL;
strlcpy(string, temp_struct->params, sizeof(string));
*var_len = strlen(string);
return (unsigned char *) string;
case SNMPTARGETADDRSTORAGETYPE:
long_ret = temp_struct->storageType;
return (unsigned char *) &long_ret;
case SNMPTARGETADDRROWSTATUS:
long_ret = temp_struct->rowStatus;
return (unsigned char *) &long_ret;
default:
DEBUGMSGTL(("snmpd",
"unknown sub-id %d in var_snmpTargetAddrEntry\n",
vp->magic));
}
return NULL;
} /* var_snmpTargetAddrEntry */
#ifndef NETSNMP_NO_WRITE_SUPPORT
int
write_snmpTargetAddrTDomain(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 targetAddrTable_struct *target = NULL;
static oid old_oid[MAX_OID_LEN];
static size_t old_oid_len;
if (action == RESERVE1) {
if (var_val_type != ASN_OBJECT_ID) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTDomain not ASN_OBJECT_ID\n"));
return SNMP_ERR_WRONGTYPE;
}
if ((var_val_len > (MAX_OID_LEN * sizeof(oid))) ||
(var_val_len % sizeof(oid) != 0)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTDomain: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
} else if (action == RESERVE2) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTDOMAINCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTDomain: BAD OID!\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
if (target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTDomain: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
if (target->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTDomain: not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
/*
* Finally, we're golden, save current value.
*/
memcpy(old_oid, target->tDomain,
target->tDomainLen * sizeof(oid));
old_oid_len = target->tDomainLen;
memcpy((u_char *) target->tDomain, var_val, var_val_len);
target->tDomainLen = var_val_len / sizeof(oid);
/*
* If row is new, check if its status can be updated.
*/
if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
(snmpTargetAddr_rowStatusCheck(target) != 0)) {
target->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
snmp_store_needed(NULL);
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTDOMAINCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) != NULL) {
if (target->storageType != SNMP_STORAGE_READONLY
&& target->rowStatus != SNMP_ROW_ACTIVE) {
memcpy((u_char *) target->tDomain, (u_char *) old_oid,
(old_oid_len * sizeof(oid)));
target->tDomainLen = old_oid_len;
if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
snmpTargetAddr_rowStatusCheck(target) == 0) {
target->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrTDomain */
int
write_snmpTargetAddrTAddress(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 targetAddrTable_struct *target = NULL;
static char *old_addr = NULL;
static size_t old_len = 0;
if (action == RESERVE1) {
if (var_val_type != ASN_OCTET_STR) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTAddress not ASN_OCTET_STR\n"));
return SNMP_ERR_WRONGTYPE;
} else if (var_val_len < 1 || var_val_len > 255) {
return SNMP_ERR_WRONGLENGTH;
}
} else if (action == RESERVE2) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTADDRESSCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTAddress: BAD OID!\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
if (target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTAddress: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
if (target->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTAddress: not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_addr = (char *) target->tAddress;
old_len = target->tAddressLen;
target->tAddress = (u_char *) malloc(var_val_len);
if (target->tAddress == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
memcpy(target->tAddress, var_val, var_val_len);
target->tAddressLen = var_val_len;
/*
* If row is new, check if its status can be updated.
*/
if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
(snmpTargetAddr_rowStatusCheck(target) != 0)) {
target->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
SNMP_FREE(old_addr);
old_addr = NULL;
snmp_store_needed(NULL);
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTADDRESSCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) != NULL) {
if (target->storageType != SNMP_STORAGE_READONLY
&& target->rowStatus != SNMP_ROW_ACTIVE) {
SNMP_FREE(target->tAddress);
target->tAddress = (u_char *) old_addr;
target->tAddressLen = old_len;
if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
snmpTargetAddr_rowStatusCheck(target) == 0) {
target->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrTAddress */
int
write_snmpTargetAddrTimeout(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)
{
/*
* variables we may use later
*/
static long long_ret;
size_t size;
struct targetAddrTable_struct *temp_struct;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTimeout not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > (size = sizeof(long_ret))) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTimeout: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
long_ret = *((long *) var_val);
if (long_ret < 0 || long_ret > 2147483647) {
return SNMP_ERR_WRONGVALUE;
}
} else if (action == RESERVE2) {
/*
* spec check range, no spec check
*/
/*
* Find row in linked list and check pertinent status...
*/
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTIMEOUTCOLUMN;
if ((temp_struct =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name, &name_len,
1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTimeout : BAD OID\n"));
return SNMP_ERR_NOSUCHNAME;
}
/*
* row exists, check if it is changeable
*/
if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTimeout : row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
} else if (action == COMMIT) {
/*
* Finally, we're golden, should we save value?
*/
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTIMEOUTCOLUMN;
if ((temp_struct =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name, &name_len,
1)) != NULL) {
temp_struct->timeout = long_ret;
}
snmp_store_needed(NULL);
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrTimeout */
int
write_snmpTargetAddrRetryCount(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 long_ret;
struct targetAddrTable_struct *target;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrRetryCount not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrRetryCount: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
long_ret = *((long *) var_val);
if (long_ret < 0 || long_ret > 255) {
return SNMP_ERR_WRONGVALUE;
}
} else if (action == RESERVE2) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRRETRYCOUNTCOLUMN;
if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen,
name, &name_len,
1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTimeout: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
if (target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrRetryCount: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
}
} else if (action == COMMIT) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRRETRYCOUNTCOLUMN;
if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen,
name, &name_len,
1)) != NULL) {
target->retryCount = long_ret;
}
snmp_store_needed(NULL);
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrRetryCount */
static int
is_delim(const char c)
{
return (c == 0x020 || c == 0x09 || c == 0x0d || c == 0x0b);
}
int
snmpTagListValid(const char *tagList, const size_t tagListLen)
{
size_t i = 0;
int inTag = 0;
for (i = 0; i < tagListLen; i++) {
if (is_delim(tagList[i]) && !inTag) {
/*
* Either a leading delimiter or two consecutive delimiters.
*/
return 0;
} else if (is_delim(tagList[i]) && inTag) {
inTag = 0;
} else if (!is_delim(tagList[i]) && !inTag) {
inTag = 1;
}
}
if (!inTag) {
/*
* Trailing delimiter.
*/
return 0;
}
return 1;
}
int
write_snmpTargetAddrTagList(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 targetAddrTable_struct *target = NULL;
static char *old_tlist;
if (action == RESERVE1) {
if (var_val_type != ASN_OCTET_STR) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTagList not ASN_OCTET_STR\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > 255) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTagList: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (!snmpTagListValid((char *) var_val, var_val_len)) {
return SNMP_ERR_WRONGVALUE;
}
} else if (action == RESERVE2) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTAGLISTCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTagList: BAD OID!\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
if (target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrTagList: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
old_tlist = target->tagList;
target->tagList = (char *) malloc(var_val_len + 1);
if (target->tagList == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
memcpy(target->tagList, var_val, var_val_len);
target->tagList[var_val_len] = '\0';
}
} else if (action == COMMIT) {
SNMP_FREE(old_tlist);
old_tlist = NULL;
snmp_store_needed(NULL);
} else if (action == FREE || action == UNDO) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRTAGLISTCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) != NULL) {
if (target->storageType != SNMP_STORAGE_READONLY) {
SNMP_FREE(target->tagList);
target->tagList = old_tlist;
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrTagList */
int
write_snmpTargetAddrParams(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 targetAddrTable_struct *target = NULL;
static char *old_params = NULL;
if (action == RESERVE1) {
if (var_val_type != ASN_OCTET_STR) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrParams not ASN_OCTET_STR\n"));
return SNMP_ERR_WRONGTYPE;
} else if (var_val_len < 1 || var_val_len > 32) {
return SNMP_ERR_WRONGLENGTH;
}
} else if (action == RESERVE2) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRPARAMSCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrParams: BAD OID!\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
if (target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrParams: row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
if (target->rowStatus == SNMP_ROW_ACTIVE) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrParams: not allowed in active row.\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
old_params = target->params;
target->params = malloc(var_val_len + 1);
if (target->params == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
memcpy(target->params, var_val, var_val_len);
target->params[var_val_len] = '\0';
/*
* If row is new, check if its status can be updated.
*/
if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
(snmpTargetAddr_rowStatusCheck(target) != 0)) {
target->rowStatus = SNMP_ROW_NOTINSERVICE;
}
}
} else if (action == COMMIT) {
SNMP_FREE(old_params);
old_params = NULL;
snmp_store_needed(NULL);
} else if (action == FREE || action == UNDO) {
/*
* Try to undo the SET here (abnormal usage of FREE clause)
*/
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRPARAMSCOLUMN;
if ((target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1)) != NULL) {
if (target->storageType != SNMP_STORAGE_READONLY
&& target->rowStatus != SNMP_ROW_ACTIVE) {
SNMP_FREE(target->params);
target->params = old_params;
if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
snmpTargetAddr_rowStatusCheck(target) == 0) {
target->rowStatus = SNMP_ROW_NOTREADY;
}
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrParams */
int
write_snmpTargetAddrStorageType(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);
struct targetAddrTable_struct *target;
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrStorageType not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrStorageType: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (long_ret != SNMP_STORAGE_OTHER &&
long_ret != SNMP_STORAGE_VOLATILE &&
long_ret != SNMP_STORAGE_NONVOLATILE) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrStorageType: attempted storage type not a valid"));
DEBUGMSG(("snmpTargetAddrEntry",
" 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) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRSTORAGETYPECOLUMN;
if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen,
name, &name_len,
1)) == NULL) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrStorageType: BAD OID\n"));
return SNMP_ERR_INCONSISTENTNAME;
} else {
if (target->storageType == SNMP_STORAGE_PERMANENT ||
target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrStorageType: row has unchangeable storage status: %d\n",
target->storageType));
return SNMP_ERR_WRONGVALUE;
}
}
} else if (action == COMMIT) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRSTORAGETYPECOLUMN;
if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen,
name, &name_len,
1)) != NULL) {
target->storageType = long_ret;
}
snmp_store_needed(NULL);
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrStorageType */
/*
* snmpTargeAddr_createNewRow is called from write_snmpTargetAddrRowStatus
* 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
snmpTargetAddr_createNewRow(oid * name, size_t name_len)
{
size_t newNameLen;
int i;
struct targetAddrTable_struct *temp_struct;
/*
* setup a new snmpTargetAddrTable structure and add it to the list
*/
newNameLen = name_len - snmpTargetAddrOIDLen;
if (newNameLen > 0) {
temp_struct = snmpTargetAddrTable_create();
if (!temp_struct)
return SNMP_ERR_GENERR;
temp_struct->nameData = (char *) malloc(newNameLen);
if (temp_struct->nameData == NULL) {
SNMP_FREE(temp_struct->tagList);
SNMP_FREE(temp_struct);
return 0;
}
temp_struct->nameLen = newNameLen;
for (i = 0; i < (int) newNameLen; i++) {
temp_struct->nameData[i] = (char) name[i + snmpTargetAddrOIDLen];
}
temp_struct->rowStatus = SNMP_ROW_NOTREADY;
snmpTargetAddrTable_addToList(temp_struct, &aAddrTable);
return 1;
}
return 0;
} /* snmpTargetAddr_createNewRow */
/*
* Assign a value to the Row Status variable
*/
int
write_snmpTargetAddrRowStatus(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 targetAddrTable_struct *target = NULL;
if (action == RESERVE1) {
value = *((long *) var_val);
if (var_val_type != ASN_INTEGER) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrRowStatus not ASN_INTEGER\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(long)) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"write to snmpTargetAddrRowStatus: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (value == RS_NOTREADY || value < 1 || value > 6) {
return SNMP_ERR_WRONGVALUE;
}
/*
* Check index value is reasonable.
*/
if (name_len < snmpTargetAddrOIDLen + 1 ||
name_len > snmpTargetAddrOIDLen + 32) {
DEBUGMSGTL(("snmpTargetAddrEntry", "bad index length %d\n",
(int)(name_len - snmpTargetAddrOIDLen)));
return SNMP_ERR_NOCREATION;
}
/*
* Search for struct in linked list.
*/
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRROWSTATUSCOLUMN;
target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1);
if (target != NULL) {
if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
value = RS_NOTREADY;
return SNMP_ERR_INCONSISTENTVALUE;
}
if (target->storageType == SNMP_STORAGE_READONLY) {
DEBUGMSGTL(("snmpTargetAddrEntry", "row is read only\n"));
return SNMP_ERR_NOTWRITABLE;
}
if (target->storageType == SNMP_STORAGE_PERMANENT) {
if (value == RS_DESTROY) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"unable to destroy permanent row\n"));
return SNMP_ERR_INCONSISTENTVALUE;
}
}
} else {
if (value == RS_ACTIVE || value == RS_NOTINSERVICE) {
return SNMP_ERR_INCONSISTENTVALUE;
}
if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
if (snmpTargetAddr_createNewRow(name, name_len) == 0) {
DEBUGMSGTL(("snmpTargetAddrEntry",
"couldn't malloc() new row\n"));
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
}
}
} else if (action == ACTION) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRROWSTATUSCOLUMN;
target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1);
if (target != NULL) {
if (value == RS_CREATEANDGO) {
/*
* Check whether all the required objects have been set.
*/
if (snmpTargetAddr_rowStatusCheck(target)) {
target->rowStatus = RS_ACTIVE;
} else {
target->rowStatus = RS_NOTREADY;
}
} else if (value == RS_CREATEANDWAIT) {
/*
* Check whether all the required objects have been set.
*/
if (snmpTargetAddr_rowStatusCheck(target)) {
target->rowStatus = RS_NOTINSERVICE;
} else {
target->rowStatus = RS_NOTREADY;
}
} else if (value == RS_ACTIVE) {
if (target->rowStatus == RS_NOTINSERVICE) {
target->rowStatus = RS_ACTIVE;
} else if (target->rowStatus == RS_NOTREADY) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else if (value == RS_NOTINSERVICE) {
if (target->rowStatus == RS_ACTIVE) {
target->rowStatus = RS_NOTINSERVICE;
} else if (target->rowStatus == RS_NOTREADY) {
return SNMP_ERR_INCONSISTENTVALUE;
}
}
}
} else if (action == COMMIT) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRROWSTATUSCOLUMN;
target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1);
if (target != NULL) {
if (value == RS_DESTROY) {
snmpTargetAddrTable_remFromList(target, &aAddrTable);
}
if (value == RS_NOTINSERVICE) {
if (target->sess != NULL) {
snmp_close(target->sess);
target->sess = NULL;
}
}
}
snmp_store_needed(NULL);
} else if (action == UNDO || action == FREE) {
snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
SNMPTARGETADDRROWSTATUSCOLUMN;
target =
search_snmpTargetAddrTable(snmpTargetAddrOID,
snmpTargetAddrOIDLen, name,
&name_len, 1);
if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
if (target != NULL) {
snmpTargetAddrTable_remFromList(target, &aAddrTable);
}
}
}
return SNMP_ERR_NOERROR;
} /* write_snmpTargetAddrRowStatus */
int
write_targetSpinLock(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)
{
if (action == RESERVE1) {
if (var_val_type != ASN_INTEGER) {
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != sizeof(unsigned long)) {
return SNMP_ERR_WRONGLENGTH;
}
if (*((unsigned long *) var_val) != snmpTargetSpinLock) {
return SNMP_ERR_INCONSISTENTVALUE;
}
} else if (action == COMMIT) {
if (snmpTargetSpinLock == 2147483647) {
snmpTargetSpinLock = 0;
} else {
snmpTargetSpinLock++;
}
}
return SNMP_ERR_NOERROR;
}
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
u_char *
var_targetSpinLock(struct variable * vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
if (header_generic(vp, name, length, exact, var_len, write_method) ==
MATCH_FAILED) {
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_targetSpinLock;
#else
*write_method = NULL;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
return NULL;
}
if (vp->magic == SNMPTARGETSPINLOCK) {
*var_len = sizeof(unsigned long);
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method = write_targetSpinLock;
#else
*write_method = NULL;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
return (u_char *) & (snmpTargetSpinLock);
}
return NULL;
}