Literal references to /usr/local exist in a large number of files in the FreeBSD base system. Many are in contributed software, in configuration files, or in the documentation, but 19 uses have been identified in C source files or headers outside the contrib and sys/contrib directories. This commit makes it possible to set _PATH_LOCALBASE in paths.h to use a different prefix for locally installed software. In order to avoid changes to openssh source files, LOCALBASE is passed to the build via Makefiles under src/secure. While _PATH_LOCALBASE could have been used here, there is precedent in the construction of the path used to a xauth program which depends on the LOCALBASE value passed on the compiler command line to select a non-default directory. This could be changed in a later commit to make the openssh build consistently use _PATH_LOCALBASE. It is considered out-of-scope for this commit. Reviewed by: imp MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D26942
970 lines
20 KiB
C
970 lines
20 KiB
C
/*-
|
|
* Copyright (c) 2006 The FreeBSD Project
|
|
* All rights reserved.
|
|
*
|
|
* Author: Shteryana Shopova <syrinx@FreeBSD.org>
|
|
*
|
|
* Redistribution of this software and documentation and use in source and
|
|
* binary forms, with or without modification, are permitted provided that
|
|
* the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code or documentation must retain the above
|
|
* copyright notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
/*
|
|
* Read file containing table description - reuse magic from gensnmptree.c.
|
|
* Hopefully one day most of the code here will be part of libbsnmp and
|
|
* this duplication won't be necessary.
|
|
*
|
|
* Syntax is:
|
|
* ---------
|
|
* file := top | top file
|
|
*
|
|
* top := tree | typedef | include
|
|
*
|
|
* tree := head elements ')'
|
|
*
|
|
* entry := head ':' index STRING elements ')'
|
|
*
|
|
* leaf := head type STRING ACCESS ')'
|
|
*
|
|
* column := head type ACCESS ')'
|
|
*
|
|
* type := BASETYPE | BASETYPE '|' subtype | enum | bits
|
|
*
|
|
* subtype := STRING
|
|
*
|
|
* enum := ENUM '(' value ')'
|
|
*
|
|
* bits := BITS '(' value ')'
|
|
*
|
|
* value := INT STRING | INT STRING value
|
|
*
|
|
* head := '(' INT STRING
|
|
*
|
|
* elements := EMPTY | elements element
|
|
*
|
|
* element := tree | leaf | column
|
|
*
|
|
* index := type | index type
|
|
*
|
|
* typedef := 'typedef' STRING type
|
|
*
|
|
* include := 'include' filespec
|
|
*
|
|
* filespec := '"' STRING '"' | '<' STRING '>'
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/uio.h>
|
|
|
|
#include <ctype.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <paths.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <syslog.h>
|
|
#include <unistd.h>
|
|
|
|
#include <bsnmp/asn1.h>
|
|
#include <bsnmp/snmp.h>
|
|
#include <bsnmp/snmpagent.h> /* SNMP_INDEXES_MAX */
|
|
#include "bsnmptc.h"
|
|
#include "bsnmptools.h"
|
|
|
|
enum snmp_tbl_entry {
|
|
ENTRY_NONE = 0,
|
|
ENTRY_INDEX,
|
|
ENTRY_DATA
|
|
};
|
|
|
|
enum {
|
|
FL_GET = 0x01,
|
|
FL_SET = 0x02,
|
|
};
|
|
|
|
/************************************************************
|
|
*
|
|
* Allocate memory and panic just in the case...
|
|
*/
|
|
static void *
|
|
xalloc(size_t size)
|
|
{
|
|
void *ptr;
|
|
|
|
if ((ptr = malloc(size)) == NULL)
|
|
err(1, "allocing %zu bytes", size);
|
|
|
|
return (ptr);
|
|
}
|
|
|
|
static char *
|
|
savestr(const char *s)
|
|
{
|
|
if (s == NULL)
|
|
return (NULL);
|
|
|
|
return (strcpy(xalloc(strlen(s) + 1), s));
|
|
}
|
|
|
|
/************************************************************
|
|
*
|
|
* Input stack
|
|
*/
|
|
struct input {
|
|
FILE *fp;
|
|
uint32_t lno;
|
|
char *fname;
|
|
char *path;
|
|
LIST_ENTRY(input) link;
|
|
};
|
|
|
|
static LIST_HEAD(, input) inputs = LIST_HEAD_INITIALIZER(inputs);
|
|
static struct input *input = NULL;
|
|
static int32_t pbchar = -1;
|
|
|
|
#define MAX_PATHS 100
|
|
|
|
static const char *paths[MAX_PATHS + 1] = {
|
|
"/usr/share/snmp/defs",
|
|
_PATH_LOCALBASE "/share/snmp/defs",
|
|
NULL
|
|
};
|
|
|
|
static void
|
|
input_new(FILE *fp, const char *path, const char *fname)
|
|
{
|
|
struct input *ip;
|
|
|
|
ip = xalloc(sizeof(*ip));
|
|
ip->fp = fp;
|
|
ip->lno = 1;
|
|
ip->fname = savestr(fname);
|
|
ip->path = savestr(path);
|
|
LIST_INSERT_HEAD(&inputs, ip, link);
|
|
|
|
input = ip;
|
|
}
|
|
|
|
static void
|
|
input_close(void)
|
|
{
|
|
if (input == NULL)
|
|
return;
|
|
|
|
fclose(input->fp);
|
|
free(input->fname);
|
|
free(input->path);
|
|
LIST_REMOVE(input, link);
|
|
free(input);
|
|
|
|
input = LIST_FIRST(&inputs);
|
|
}
|
|
|
|
static FILE *
|
|
tryopen(const char *path, const char *fname)
|
|
{
|
|
char *fn;
|
|
FILE *fp;
|
|
|
|
if (path == NULL)
|
|
fn = savestr(fname);
|
|
else {
|
|
fn = xalloc(strlen(path) + strlen(fname) + 2);
|
|
sprintf(fn, "%s/%s", path, fname);
|
|
}
|
|
fp = fopen(fn, "r");
|
|
free(fn);
|
|
return (fp);
|
|
}
|
|
|
|
static int32_t
|
|
input_fopen(const char *fname)
|
|
{
|
|
FILE *fp;
|
|
u_int p;
|
|
|
|
if (fname[0] == '/' || fname[0] == '.' || fname[0] == '~') {
|
|
if ((fp = tryopen(NULL, fname)) != NULL) {
|
|
input_new(fp, NULL, fname);
|
|
return (0);
|
|
}
|
|
|
|
} else {
|
|
|
|
for (p = 0; paths[p] != NULL; p++)
|
|
if ((fp = tryopen(paths[p], fname)) != NULL) {
|
|
input_new(fp, paths[p], fname);
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
warnx("cannot open '%s'", fname);
|
|
return (-1);
|
|
}
|
|
|
|
static int32_t
|
|
tgetc(void)
|
|
{
|
|
int c;
|
|
|
|
if (pbchar != -1) {
|
|
c = pbchar;
|
|
pbchar = -1;
|
|
return (c);
|
|
}
|
|
|
|
for (;;) {
|
|
if (input == NULL)
|
|
return (EOF);
|
|
|
|
if ((c = getc(input->fp)) != EOF)
|
|
return (c);
|
|
|
|
input_close();
|
|
}
|
|
}
|
|
|
|
static int32_t
|
|
tungetc(int c)
|
|
{
|
|
|
|
if (pbchar != -1)
|
|
return (-1);
|
|
|
|
pbchar = c;
|
|
return (1);
|
|
}
|
|
|
|
/************************************************************
|
|
*
|
|
* Parsing input
|
|
*/
|
|
enum tok {
|
|
TOK_EOF = 0200, /* end-of-file seen */
|
|
TOK_NUM, /* number */
|
|
TOK_STR, /* string */
|
|
TOK_ACCESS, /* access operator */
|
|
TOK_TYPE, /* type operator */
|
|
TOK_ENUM, /* enum token (kind of a type) */
|
|
TOK_TYPEDEF, /* typedef directive */
|
|
TOK_DEFTYPE, /* defined type */
|
|
TOK_INCLUDE, /* include directive */
|
|
TOK_FILENAME, /* filename ("foo.bar" or <foo.bar>) */
|
|
TOK_BITS, /* bits token (kind of a type) */
|
|
TOK_ERR /* unexpected char - exit */
|
|
};
|
|
|
|
static const struct {
|
|
const char *str;
|
|
enum tok tok;
|
|
uint32_t val;
|
|
} keywords[] = {
|
|
{ "GET", TOK_ACCESS, FL_GET },
|
|
{ "SET", TOK_ACCESS, FL_SET },
|
|
{ "NULL", TOK_TYPE, SNMP_SYNTAX_NULL },
|
|
{ "INTEGER", TOK_TYPE, SNMP_SYNTAX_INTEGER },
|
|
{ "INTEGER32", TOK_TYPE, SNMP_SYNTAX_INTEGER },
|
|
{ "UNSIGNED32", TOK_TYPE, SNMP_SYNTAX_GAUGE },
|
|
{ "OCTETSTRING", TOK_TYPE, SNMP_SYNTAX_OCTETSTRING },
|
|
{ "IPADDRESS", TOK_TYPE, SNMP_SYNTAX_IPADDRESS },
|
|
{ "OID", TOK_TYPE, SNMP_SYNTAX_OID },
|
|
{ "TIMETICKS", TOK_TYPE, SNMP_SYNTAX_TIMETICKS },
|
|
{ "COUNTER", TOK_TYPE, SNMP_SYNTAX_COUNTER },
|
|
{ "GAUGE", TOK_TYPE, SNMP_SYNTAX_GAUGE },
|
|
{ "COUNTER64", TOK_TYPE, SNMP_SYNTAX_COUNTER64 },
|
|
{ "ENUM", TOK_ENUM, SNMP_SYNTAX_INTEGER },
|
|
{ "BITS", TOK_BITS, SNMP_SYNTAX_OCTETSTRING },
|
|
{ "typedef", TOK_TYPEDEF, 0 },
|
|
{ "include", TOK_INCLUDE, 0 },
|
|
{ NULL, 0, 0 }
|
|
};
|
|
|
|
static struct {
|
|
/* Current OID type, regarding table membership. */
|
|
enum snmp_tbl_entry tbl_type;
|
|
/* A pointer to a structure in table list to add to its members. */
|
|
struct snmp_index_entry *table_idx;
|
|
} table_data;
|
|
|
|
static struct asn_oid current_oid;
|
|
static char nexttok[MAXSTR];
|
|
static u_long val; /* integer values */
|
|
static int32_t all_cond; /* all conditions are true */
|
|
static int32_t saved_token = -1;
|
|
|
|
/* Prepare the global data before parsing a new file. */
|
|
static void
|
|
snmp_import_init(struct asn_oid *append)
|
|
{
|
|
memset(&table_data, 0, sizeof(table_data));
|
|
memset(¤t_oid, 0, sizeof(struct asn_oid));
|
|
memset(nexttok, 0, MAXSTR);
|
|
|
|
if (append != NULL)
|
|
asn_append_oid(¤t_oid, append);
|
|
|
|
all_cond = 0;
|
|
val = 0;
|
|
saved_token = -1;
|
|
}
|
|
|
|
static int32_t
|
|
gettoken(struct snmp_toolinfo *snmptoolctx)
|
|
{
|
|
int c;
|
|
struct enum_type *t;
|
|
|
|
if (saved_token != -1) {
|
|
c = saved_token;
|
|
saved_token = -1;
|
|
return (c);
|
|
}
|
|
|
|
again:
|
|
/*
|
|
* Skip any whitespace before the next token.
|
|
*/
|
|
while ((c = tgetc()) != EOF) {
|
|
if (c == '\n')
|
|
input->lno++;
|
|
if (!isspace(c))
|
|
break;
|
|
}
|
|
if (c == EOF)
|
|
return (TOK_EOF);
|
|
|
|
if (!isascii(c)) {
|
|
warnx("unexpected character %#2x", (u_int) c);
|
|
return (TOK_ERR);
|
|
}
|
|
|
|
/*
|
|
* Skip comments.
|
|
*/
|
|
if (c == '#') {
|
|
while ((c = tgetc()) != EOF) {
|
|
if (c == '\n') {
|
|
input->lno++;
|
|
goto again;
|
|
}
|
|
}
|
|
warnx("unexpected EOF in comment");
|
|
return (TOK_ERR);
|
|
}
|
|
|
|
/*
|
|
* Single character tokens.
|
|
*/
|
|
if (strchr("():|", c) != NULL)
|
|
return (c);
|
|
|
|
if (c == '"' || c == '<') {
|
|
int32_t end = c;
|
|
size_t n = 0;
|
|
|
|
val = 1;
|
|
if (c == '<') {
|
|
val = 0;
|
|
end = '>';
|
|
}
|
|
|
|
while ((c = tgetc()) != EOF) {
|
|
if (c == end)
|
|
break;
|
|
if (n == sizeof(nexttok) - 1) {
|
|
nexttok[n++] = '\0';
|
|
warnx("filename too long '%s...'", nexttok);
|
|
return (TOK_ERR);
|
|
}
|
|
nexttok[n++] = c;
|
|
}
|
|
nexttok[n++] = '\0';
|
|
return (TOK_FILENAME);
|
|
}
|
|
|
|
/*
|
|
* Sort out numbers.
|
|
*/
|
|
if (isdigit(c)) {
|
|
size_t n = 0;
|
|
nexttok[n++] = c;
|
|
while ((c = tgetc()) != EOF) {
|
|
if (!isdigit(c)) {
|
|
if (tungetc(c) < 0)
|
|
return (TOK_ERR);
|
|
break;
|
|
}
|
|
if (n == sizeof(nexttok) - 1) {
|
|
nexttok[n++] = '\0';
|
|
warnx("number too long '%s...'", nexttok);
|
|
return (TOK_ERR);
|
|
}
|
|
nexttok[n++] = c;
|
|
}
|
|
nexttok[n++] = '\0';
|
|
sscanf(nexttok, "%lu", &val);
|
|
return (TOK_NUM);
|
|
}
|
|
|
|
/*
|
|
* So that has to be a string.
|
|
*/
|
|
if (isalpha(c) || c == '_' || c == '-') {
|
|
size_t n = 0;
|
|
nexttok[n++] = c;
|
|
while ((c = tgetc()) != EOF) {
|
|
if (!isalnum(c) && c != '_' && c != '-') {
|
|
if (tungetc (c) < 0)
|
|
return (TOK_ERR);
|
|
break;
|
|
}
|
|
if (n == sizeof(nexttok) - 1) {
|
|
nexttok[n++] = '\0';
|
|
warnx("string too long '%s...'", nexttok);
|
|
return (TOK_ERR);
|
|
}
|
|
nexttok[n++] = c;
|
|
}
|
|
nexttok[n++] = '\0';
|
|
|
|
/*
|
|
* Keywords.
|
|
*/
|
|
for (c = 0; keywords[c].str != NULL; c++)
|
|
if (strcmp(keywords[c].str, nexttok) == 0) {
|
|
val = keywords[c].val;
|
|
return (keywords[c].tok);
|
|
}
|
|
|
|
if ((t = snmp_enumtc_lookup(snmptoolctx, nexttok)) != NULL) {
|
|
val = t->syntax;
|
|
return (TOK_DEFTYPE);
|
|
}
|
|
|
|
return (TOK_STR);
|
|
}
|
|
|
|
if (isprint(c))
|
|
warnx("%u: unexpected character '%c'", input->lno, c);
|
|
else
|
|
warnx("%u: unexpected character 0x%02x", input->lno, (u_int) c);
|
|
|
|
return (TOK_ERR);
|
|
}
|
|
|
|
/*
|
|
* Update table information.
|
|
*/
|
|
static struct snmp_index_entry *
|
|
snmp_import_update_table(enum snmp_tbl_entry te, struct snmp_index_entry *tbl)
|
|
{
|
|
switch (te) {
|
|
case ENTRY_NONE:
|
|
if (table_data.tbl_type == ENTRY_NONE)
|
|
return (NULL);
|
|
if (table_data.tbl_type == ENTRY_INDEX)
|
|
table_data.table_idx = NULL;
|
|
table_data.tbl_type--;
|
|
return (NULL);
|
|
|
|
case ENTRY_INDEX:
|
|
if (tbl == NULL)
|
|
warnx("No table_index to add!!!");
|
|
table_data.table_idx = tbl;
|
|
table_data.tbl_type = ENTRY_INDEX;
|
|
return (tbl);
|
|
|
|
case ENTRY_DATA:
|
|
if (table_data.tbl_type == ENTRY_INDEX) {
|
|
table_data.tbl_type = ENTRY_DATA;
|
|
return (table_data.table_idx);
|
|
}
|
|
return (NULL);
|
|
|
|
default:
|
|
/* NOTREACHED */
|
|
warnx("Unknown table entry type!!!");
|
|
break;
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
static int32_t
|
|
parse_enum(struct snmp_toolinfo *snmptoolctx, int32_t *tok,
|
|
struct enum_pairs *enums)
|
|
{
|
|
while ((*tok = gettoken(snmptoolctx)) == TOK_STR) {
|
|
if (enum_pair_insert(enums, val, nexttok) < 0)
|
|
return (-1);
|
|
if ((*tok = gettoken(snmptoolctx)) != TOK_NUM)
|
|
break;
|
|
}
|
|
|
|
if (*tok != ')') {
|
|
warnx("')' at end of enums");
|
|
return (-1);
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
static int32_t
|
|
parse_subtype(struct snmp_toolinfo *snmptoolctx, int32_t *tok,
|
|
enum snmp_tc *tc)
|
|
{
|
|
if ((*tok = gettoken(snmptoolctx)) != TOK_STR) {
|
|
warnx("subtype expected after '|'");
|
|
return (-1);
|
|
}
|
|
|
|
*tc = snmp_get_tc(nexttok);
|
|
*tok = gettoken(snmptoolctx);
|
|
|
|
return (1);
|
|
}
|
|
|
|
static int32_t
|
|
parse_type(struct snmp_toolinfo *snmptoolctx, int32_t *tok,
|
|
enum snmp_tc *tc, struct enum_pairs **snmp_enum)
|
|
{
|
|
int32_t syntax, mem;
|
|
|
|
syntax = val;
|
|
*tc = 0;
|
|
|
|
if (*tok == TOK_ENUM || *tok == TOK_BITS) {
|
|
if (*snmp_enum == NULL) {
|
|
if ((*snmp_enum = enum_pairs_init()) == NULL)
|
|
return (-1);
|
|
mem = 1;
|
|
*tc = SNMP_TC_OWN;
|
|
} else
|
|
mem = 0;
|
|
|
|
if (gettoken(snmptoolctx) != '(') {
|
|
warnx("'(' expected after ENUM/BITS");
|
|
return (-1);
|
|
}
|
|
|
|
if ((*tok = gettoken(snmptoolctx)) != TOK_NUM) {
|
|
warnx("need value for ENUM//BITS");
|
|
if (mem == 1) {
|
|
free(*snmp_enum);
|
|
*snmp_enum = NULL;
|
|
}
|
|
return (-1);
|
|
}
|
|
|
|
if (parse_enum(snmptoolctx, tok, *snmp_enum) < 0) {
|
|
enum_pairs_free(*snmp_enum);
|
|
*snmp_enum = NULL;
|
|
return (-1);
|
|
}
|
|
|
|
*tok = gettoken(snmptoolctx);
|
|
|
|
} else if (*tok == TOK_DEFTYPE) {
|
|
struct enum_type *t;
|
|
|
|
*tc = 0;
|
|
t = snmp_enumtc_lookup(snmptoolctx, nexttok);
|
|
if (t != NULL)
|
|
*snmp_enum = t->snmp_enum;
|
|
|
|
*tok = gettoken(snmptoolctx);
|
|
|
|
} else {
|
|
if ((*tok = gettoken(snmptoolctx)) == '|') {
|
|
if (parse_subtype(snmptoolctx, tok, tc) < 0)
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
return (syntax);
|
|
}
|
|
|
|
static int32_t
|
|
snmp_import_head(struct snmp_toolinfo *snmptoolctx)
|
|
{
|
|
enum tok tok;
|
|
|
|
if ((tok = gettoken(snmptoolctx)) == '(')
|
|
tok = gettoken(snmptoolctx);
|
|
|
|
if (tok != TOK_NUM || val > ASN_MAXID ) {
|
|
warnx("Suboid expected - line %d", input->lno);
|
|
return (-1);
|
|
}
|
|
|
|
if (gettoken(snmptoolctx) != TOK_STR) {
|
|
warnx("Node name expected at line %d", input->lno);
|
|
return (-1);
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
static int32_t
|
|
snmp_import_table(struct snmp_toolinfo *snmptoolctx, struct snmp_oid2str *obj)
|
|
{
|
|
int32_t i, tok;
|
|
enum snmp_tc tc;
|
|
struct snmp_index_entry *entry;
|
|
|
|
if ((entry = calloc(1, sizeof(struct snmp_index_entry))) == NULL) {
|
|
syslog(LOG_ERR, "malloc() failed: %s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
STAILQ_INIT(&(entry->index_list));
|
|
|
|
for (i = 0, tok = gettoken(snmptoolctx); i < SNMP_INDEXES_MAX; i++) {
|
|
int32_t syntax;
|
|
struct enum_pairs *enums = NULL;
|
|
|
|
if (tok != TOK_TYPE && tok != TOK_DEFTYPE && tok != TOK_ENUM &&
|
|
tok != TOK_BITS)
|
|
break;
|
|
|
|
if ((syntax = parse_type(snmptoolctx, &tok, &tc, &enums)) < 0) {
|
|
enum_pairs_free(enums);
|
|
snmp_index_listfree(&(entry->index_list));
|
|
free(entry);
|
|
return (-1);
|
|
}
|
|
|
|
if (snmp_syntax_insert(&(entry->index_list), enums, syntax,
|
|
tc) < 0) {
|
|
snmp_index_listfree(&(entry->index_list));
|
|
enum_pairs_free(enums);
|
|
free(entry);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
if (i == 0 || i > SNMP_INDEXES_MAX) {
|
|
warnx("Bad number of indexes at line %d", input->lno);
|
|
snmp_index_listfree(&(entry->index_list));
|
|
free(entry);
|
|
return (-1);
|
|
}
|
|
|
|
if (tok != TOK_STR) {
|
|
warnx("String expected after indexes at line %d", input->lno);
|
|
snmp_index_listfree(&(entry->index_list));
|
|
free(entry);
|
|
return (-1);
|
|
}
|
|
|
|
entry->string = obj->string;
|
|
entry->strlen = obj->strlen;
|
|
asn_append_oid(&(entry->var), &(obj->var));
|
|
|
|
if ((i = snmp_table_insert(snmptoolctx, entry)) < 0) {
|
|
snmp_index_listfree(&(entry->index_list));
|
|
free(entry);
|
|
return (-1);
|
|
} else if (i == 0) {
|
|
/* Same entry already present in lists. */
|
|
free(entry->string);
|
|
free(entry);
|
|
return (0);
|
|
}
|
|
|
|
(void) snmp_import_update_table(ENTRY_INDEX, entry);
|
|
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Read everything after the syntax type that is certainly a leaf OID info.
|
|
*/
|
|
static int32_t
|
|
snmp_import_leaf(struct snmp_toolinfo *snmptoolctx, int32_t *tok,
|
|
struct snmp_oid2str *oid2str)
|
|
{
|
|
int32_t i, syntax;
|
|
|
|
if ((syntax = parse_type(snmptoolctx, tok, &(oid2str->tc), &(oid2str->snmp_enum)))
|
|
< 0)
|
|
return(-1);
|
|
|
|
oid2str->syntax = syntax;
|
|
/*
|
|
* That is the name of the function, corresponding to the entry.
|
|
* It is used by bsnmpd, but is not interesting for us.
|
|
*/
|
|
if (*tok == TOK_STR)
|
|
*tok = gettoken(snmptoolctx);
|
|
|
|
for (i = 0; i < SNMP_ACCESS_GETSET && *tok == TOK_ACCESS; i++) {
|
|
oid2str->access |= (uint32_t) val;
|
|
*tok = gettoken(snmptoolctx);
|
|
}
|
|
|
|
if (*tok != ')') {
|
|
warnx("')' expected at end of line %d", input->lno);
|
|
return (-1);
|
|
}
|
|
|
|
oid2str->table_idx = snmp_import_update_table(ENTRY_DATA, NULL);
|
|
|
|
if ((i = snmp_leaf_insert(snmptoolctx, oid2str)) < 0) {
|
|
warnx("Error adding leaf %s to list", oid2str->string);
|
|
return (-1);
|
|
}
|
|
|
|
/*
|
|
* Same entry is already present in the mapping lists and
|
|
* the new one was not inserted.
|
|
*/
|
|
if (i == 0) {
|
|
free(oid2str->string);
|
|
free(oid2str);
|
|
}
|
|
|
|
(void) snmp_import_update_table(ENTRY_NONE, NULL);
|
|
|
|
return (1);
|
|
}
|
|
|
|
static int32_t
|
|
snmp_import_object(struct snmp_toolinfo *snmptoolctx)
|
|
{
|
|
char *string;
|
|
int i;
|
|
int32_t tok;
|
|
struct snmp_oid2str *oid2str;
|
|
|
|
if (snmp_import_head(snmptoolctx) < 0)
|
|
return (-1);
|
|
|
|
if ((oid2str = calloc(1, sizeof(struct snmp_oid2str))) == NULL) {
|
|
syslog(LOG_ERR, "calloc() failed: %s", strerror(errno));
|
|
return (-1);
|
|
}
|
|
|
|
if ((string = strdup(nexttok)) == NULL) {
|
|
syslog(LOG_ERR, "strdup() failed: %s", strerror(errno));
|
|
free(oid2str);
|
|
return (-1);
|
|
}
|
|
|
|
oid2str->string = string;
|
|
oid2str->strlen = strlen(nexttok);
|
|
|
|
asn_append_oid(&(oid2str->var), &(current_oid));
|
|
if (snmp_suboid_append(&(oid2str->var), (asn_subid_t) val) < 0)
|
|
goto error;
|
|
|
|
/*
|
|
* Prepared the entry - now figure out where to insert it.
|
|
* After the object we have following options:
|
|
* 1) new line, blank, ) - then it is an enum oid -> snmp_enumlist;
|
|
* 2) new line , ( - nonleaf oid -> snmp_nodelist;
|
|
* 2) ':' - table entry - a variable length SYNTAX_TYPE (one or more)
|
|
* may follow and second string must end line -> snmp_tablelist;
|
|
* 3) OID , string ) - this is a trap entry or a leaf -> snmp_oidlist;
|
|
* 4) SYNTAX_TYPE, string (not always), get/set modifier - always last
|
|
* and )- this is definitely a leaf.
|
|
*/
|
|
|
|
switch (tok = gettoken(snmptoolctx)) {
|
|
case ')':
|
|
if ((i = snmp_enum_insert(snmptoolctx, oid2str)) < 0)
|
|
goto error;
|
|
if (i == 0) {
|
|
free(oid2str->string);
|
|
free(oid2str);
|
|
}
|
|
return (1);
|
|
|
|
case '(':
|
|
if (snmp_suboid_append(¤t_oid, (asn_subid_t) val) < 0)
|
|
goto error;
|
|
|
|
/*
|
|
* Ignore the error for nodes since the .def files currently
|
|
* contain different strings for 1.3.6.1.2.1 - mibII. Only make
|
|
* sure the memory is freed and don't complain.
|
|
*/
|
|
if ((i = snmp_node_insert(snmptoolctx, oid2str)) <= 0) {
|
|
free(string);
|
|
free(oid2str);
|
|
}
|
|
return (snmp_import_object(snmptoolctx));
|
|
|
|
case ':':
|
|
if (snmp_suboid_append(¤t_oid, (asn_subid_t) val) < 0)
|
|
goto error;
|
|
if (snmp_import_table(snmptoolctx, oid2str) < 0)
|
|
goto error;
|
|
/*
|
|
* A different table entry type was malloced and the data is
|
|
* contained there.
|
|
*/
|
|
free(oid2str);
|
|
return (1);
|
|
|
|
case TOK_TYPE:
|
|
/* FALLTHROUGH */
|
|
case TOK_DEFTYPE:
|
|
/* FALLTHROUGH */
|
|
case TOK_ENUM:
|
|
/* FALLTHROUGH */
|
|
case TOK_BITS:
|
|
if (snmp_import_leaf(snmptoolctx, &tok, oid2str) < 0)
|
|
goto error;
|
|
return (1);
|
|
|
|
default:
|
|
warnx("Unexpected token at line %d - %s", input->lno,
|
|
input->fname);
|
|
break;
|
|
}
|
|
|
|
error:
|
|
snmp_mapping_entryfree(oid2str);
|
|
|
|
return (-1);
|
|
}
|
|
|
|
static int32_t
|
|
snmp_import_tree(struct snmp_toolinfo *snmptoolctx, int32_t *tok)
|
|
{
|
|
while (*tok != TOK_EOF) {
|
|
switch (*tok) {
|
|
case TOK_ERR:
|
|
return (-1);
|
|
case '(':
|
|
if (snmp_import_object(snmptoolctx) < 0)
|
|
return (-1);
|
|
break;
|
|
case ')':
|
|
if (snmp_suboid_pop(¤t_oid) < 0)
|
|
return (-1);
|
|
(void) snmp_import_update_table(ENTRY_NONE, NULL);
|
|
break;
|
|
default:
|
|
/* Anything else here would be illegal. */
|
|
return (-1);
|
|
}
|
|
*tok = gettoken(snmptoolctx);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int32_t
|
|
snmp_import_top(struct snmp_toolinfo *snmptoolctx, int32_t *tok)
|
|
{
|
|
enum snmp_tc tc;
|
|
struct enum_type *t;
|
|
|
|
if (*tok == '(')
|
|
return (snmp_import_tree(snmptoolctx, tok));
|
|
|
|
if (*tok == TOK_TYPEDEF) {
|
|
if ((*tok = gettoken(snmptoolctx)) != TOK_STR) {
|
|
warnx("type name expected after typedef - %s",
|
|
input->fname);
|
|
return (-1);
|
|
}
|
|
|
|
t = snmp_enumtc_init(nexttok);
|
|
|
|
*tok = gettoken(snmptoolctx);
|
|
t->is_enum = (*tok == TOK_ENUM);
|
|
t->is_bits = (*tok == TOK_BITS);
|
|
t->syntax = parse_type(snmptoolctx, tok, &tc, &(t->snmp_enum));
|
|
snmp_enumtc_insert(snmptoolctx, t);
|
|
|
|
return (1);
|
|
}
|
|
|
|
if (*tok == TOK_INCLUDE) {
|
|
int i;
|
|
|
|
*tok = gettoken(snmptoolctx);
|
|
if (*tok != TOK_FILENAME) {
|
|
warnx("filename expected in include directive - %s",
|
|
nexttok);
|
|
return (-1);
|
|
}
|
|
|
|
if (( i = add_filename(snmptoolctx, nexttok, NULL, 1)) == 0) {
|
|
*tok = gettoken(snmptoolctx);
|
|
return (1);
|
|
}
|
|
|
|
if (i == -1)
|
|
return (-1);
|
|
|
|
input_fopen(nexttok);
|
|
*tok = gettoken(snmptoolctx);
|
|
return (1);
|
|
}
|
|
|
|
warnx("'(' or 'typedef' expected - %s", nexttok);
|
|
return (-1);
|
|
}
|
|
|
|
static int32_t
|
|
snmp_import(struct snmp_toolinfo *snmptoolctx)
|
|
{
|
|
int i;
|
|
int32_t tok;
|
|
|
|
tok = gettoken(snmptoolctx);
|
|
|
|
do
|
|
i = snmp_import_top(snmptoolctx, &tok);
|
|
while (i > 0);
|
|
|
|
return (i);
|
|
}
|
|
|
|
/*
|
|
* Read a .def file and import oid<->string mapping.
|
|
* Mappings are inserted into a global structure containing list for each OID
|
|
* syntax type.
|
|
*/
|
|
int32_t
|
|
snmp_import_file(struct snmp_toolinfo *snmptoolctx, struct fname *file)
|
|
{
|
|
int idx;
|
|
|
|
snmp_import_init(&(file->cut));
|
|
input_fopen(file->name);
|
|
if ((idx = snmp_import(snmptoolctx)) < 0)
|
|
warnx("Failed to read mappings from file %s", file->name);
|
|
|
|
input_close();
|
|
|
|
return (idx);
|
|
}
|