/*
* parse_snmpNotifyTable():
* parses .conf file entries needed to configure the mib.
*/
void
parse_snmpNotifyTable(const char *token, char *line)
{
size_t tmpint;
struct snmpNotifyTable_data *StorageTmp =
SNMP_MALLOC_STRUCT(snmpNotifyTable_data);
DEBUGMSGTL(("snmpNotifyTable", "parsing config... "));
if (StorageTmp == NULL) {
config_perror("malloc failure");
return;
}
line =
read_config_read_data(ASN_OCTET_STR, line,
&StorageTmp->snmpNotifyName,
&StorageTmp->snmpNotifyNameLen);
if (StorageTmp->snmpNotifyName == NULL) {
config_perror("invalid specification for snmpNotifyName");
return;
}
line =
read_config_read_data(ASN_OCTET_STR, line,
&StorageTmp->snmpNotifyTag,
&StorageTmp->snmpNotifyTagLen);
if (StorageTmp->snmpNotifyTag == NULL) {
config_perror("invalid specification for snmpNotifyTag");
return;
}
line =
read_config_read_data(ASN_INTEGER, line,
&StorageTmp->snmpNotifyType, &tmpint);
line =
read_config_read_data(ASN_INTEGER, line,
&StorageTmp->snmpNotifyStorageType, &tmpint);
if (!StorageTmp->snmpNotifyStorageType)
StorageTmp->snmpNotifyStorageType = ST_READONLY;
line =
read_config_read_data(ASN_INTEGER, line,
&StorageTmp->snmpNotifyRowStatus, &tmpint);
if (!StorageTmp->snmpNotifyRowStatus)
StorageTmp->snmpNotifyRowStatus = RS_ACTIVE;
if (snmpNotifyTable_add(StorageTmp) != SNMPERR_SUCCESS){
SNMP_FREE(StorageTmp->snmpNotifyName);
SNMP_FREE(StorageTmp->snmpNotifyTag);
SNMP_FREE(StorageTmp);
}
DEBUGMSGTL(("snmpNotifyTable", "done.\n"));
}
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
notifyTable_register_notifications(int major, int minor,
void *serverarg, void *clientarg)
{
struct targetAddrTable_struct *ptr;
struct targetParamTable_struct *pptr;
struct snmpNotifyTable_data *nptr;
int confirm, i;
char buf[SNMP_MAXBUF_SMALL];
netsnmp_transport *t = NULL;
struct agent_add_trap_args *args =
(struct agent_add_trap_args *) serverarg;
netsnmp_session *ss;
if (!args || !(args->ss)) {
return (0);
}
confirm = args->confirm;
ss = args->ss;
/*
* XXX: START move target creation to target code
*/
for (i = 0; i < MAX_ENTRIES; i++) {
sprintf(buf, "internal%d", i);
if (get_addrForName(buf) == NULL && get_paramEntry(buf) == NULL)
break;
}
if (i == MAX_ENTRIES) {
snmp_log(LOG_ERR,
"Can't register new trap destination: max limit reached: %d",
MAX_ENTRIES);
snmp_sess_close(ss);
return (0);
}
/*
* address
*/
ptr = snmpTargetAddrTable_create();
ptr->name = strdup(buf);
t = snmp_sess_transport(snmp_sess_pointer(ss));
memcpy(ptr->tDomain, t->domain, t->domain_length * sizeof(oid));
ptr->tDomainLen = t->domain_length;
ptr->tAddressLen = t->remote_length;
ptr->tAddress = t->remote;
ptr->timeout = ss->timeout / 1000;
ptr->retryCount = ss->retries;
SNMP_FREE(ptr->tagList);
ptr->tagList = strdup(ptr->name);
ptr->params = strdup(ptr->name);
ptr->storageType = ST_READONLY;
ptr->rowStatus = RS_ACTIVE;
ptr->sess = ss;
DEBUGMSGTL(("trapsess", "adding to trap table\n"));
snmpTargetAddrTable_add(ptr);
/*
* param
*/
pptr = snmpTargetParamTable_create();
pptr->paramName = strdup(buf);
pptr->mpModel = ss->version;
if (ss->version == SNMP_VERSION_3) {
pptr->secModel = ss->securityModel;
pptr->secLevel = ss->securityLevel;
pptr->secName = (char *) malloc(ss->securityNameLen + 1);
memcpy((void *) pptr->secName, (void *) ss->securityName,
ss->securityNameLen);
pptr->secName[ss->securityNameLen] = 0;
} else {
pptr->secModel = ss->version == SNMP_VERSION_1 ?
SNMP_SEC_MODEL_SNMPv1 : SNMP_SEC_MODEL_SNMPv2c;
pptr->secLevel = SNMP_SEC_LEVEL_NOAUTH;
pptr->secName = NULL;
if (ss->community && (ss->community_len > 0)) {
pptr->secName = (char *) malloc(ss->community_len + 1);
memcpy((void *) pptr->secName, (void *) ss->community,
ss->community_len);
pptr->secName[ss->community_len] = 0;
}
}
pptr->storageType = ST_READONLY;
pptr->rowStatus = RS_ACTIVE;
snmpTargetParamTable_add(pptr);
/*
* XXX: END move target creation to target code
*/
/*
* notify table
*/
nptr = SNMP_MALLOC_STRUCT(snmpNotifyTable_data);
nptr->snmpNotifyName = strdup(buf);
nptr->snmpNotifyNameLen = strlen(buf);
nptr->snmpNotifyTag = strdup(buf);
nptr->snmpNotifyTagLen = strlen(buf);
nptr->snmpNotifyType = confirm ?
SNMPNOTIFYTYPE_INFORM : SNMPNOTIFYTYPE_TRAP;
nptr->snmpNotifyStorageType = ST_READONLY;
nptr->snmpNotifyRowStatus = RS_ACTIVE;
snmpNotifyTable_add(nptr);
return 0;
}
