d4199d75a1
basically disables any access unless other strings are set in the config file. Note, that there is no way to set the communities back to NULL once they're set to something not NULL.
2376 lines
46 KiB
C
2376 lines
46 KiB
C
/*
|
|
* Copyright (c) 2001-2003
|
|
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
|
|
* All rights reserved.
|
|
*
|
|
* Author: Harti Brandt <harti@freebsd.org>
|
|
*
|
|
* Redistribution 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 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 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 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.
|
|
*
|
|
* $Begemot: bsnmp/snmpd/main.c,v 1.97 2005/10/04 14:32:45 brandt_h Exp $
|
|
*
|
|
* SNMPd main stuff.
|
|
*/
|
|
#include <sys/param.h>
|
|
#include <sys/un.h>
|
|
#include <sys/ucred.h>
|
|
#include <sys/uio.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <syslog.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <dlfcn.h>
|
|
#include <inttypes.h>
|
|
|
|
#ifdef USE_TCPWRAPPERS
|
|
#include <arpa/inet.h>
|
|
#include <tcpd.h>
|
|
#endif
|
|
|
|
#include "snmpmod.h"
|
|
#include "snmpd.h"
|
|
#include "tree.h"
|
|
#include "oid.h"
|
|
|
|
#if !defined(INT32_MAX)
|
|
#define INT32_MAX (0x7fffffff)
|
|
#endif
|
|
|
|
#define PATH_PID "/var/run/%s.pid"
|
|
#define PATH_CONFIG "/etc/%s.config"
|
|
|
|
uint64_t this_tick; /* start of processing of current packet (absolute) */
|
|
uint64_t start_tick; /* start of processing */
|
|
|
|
struct systemg systemg = {
|
|
NULL,
|
|
{ 8, { 1, 3, 6, 1, 4, 1, 1115, 7352 }},
|
|
NULL, NULL, NULL,
|
|
64 + 8 + 4,
|
|
0
|
|
};
|
|
struct debug debug = {
|
|
0, /* dump_pdus */
|
|
LOG_DEBUG, /* log_pri */
|
|
0, /* evdebug */
|
|
};
|
|
|
|
struct snmpd snmpd = {
|
|
2048, /* txbuf */
|
|
2048, /* rxbuf */
|
|
0, /* comm_dis */
|
|
0, /* auth_traps */
|
|
{0, 0, 0, 0}, /* trap1addr */
|
|
VERS_ENABLE_ALL,/* version_enable */
|
|
};
|
|
struct snmpd_stats snmpd_stats;
|
|
|
|
/* snmpSerialNo */
|
|
int32_t snmp_serial_no;
|
|
|
|
/* search path for config files */
|
|
const char *syspath = PATH_SYSCONFIG;
|
|
|
|
/* list of all loaded modules */
|
|
struct lmodules lmodules = TAILQ_HEAD_INITIALIZER(lmodules);
|
|
|
|
/* list of loaded modules during start-up in the order they were loaded */
|
|
static struct lmodules modules_start = TAILQ_HEAD_INITIALIZER(modules_start);
|
|
|
|
/* list of all known communities */
|
|
struct community_list community_list = TAILQ_HEAD_INITIALIZER(community_list);
|
|
|
|
/* list of all installed object resources */
|
|
struct objres_list objres_list = TAILQ_HEAD_INITIALIZER(objres_list);
|
|
|
|
/* community value generator */
|
|
static u_int next_community_index = 1;
|
|
|
|
/* list of all known ranges */
|
|
struct idrange_list idrange_list = TAILQ_HEAD_INITIALIZER(idrange_list);
|
|
|
|
/* identifier generator */
|
|
u_int next_idrange = 1;
|
|
|
|
/* list of all current timers */
|
|
struct timer_list timer_list = LIST_HEAD_INITIALIZER(timer_list);
|
|
|
|
/* list of file descriptors */
|
|
struct fdesc_list fdesc_list = LIST_HEAD_INITIALIZER(fdesc_list);
|
|
|
|
/* program arguments */
|
|
static char **progargs;
|
|
static int nprogargs;
|
|
|
|
/* current community */
|
|
u_int community;
|
|
static struct community *comm;
|
|
|
|
/* file names */
|
|
static char config_file[MAXPATHLEN + 1];
|
|
static char pid_file[MAXPATHLEN + 1];
|
|
|
|
#ifndef USE_LIBBEGEMOT
|
|
/* event context */
|
|
static evContext evctx;
|
|
#endif
|
|
|
|
/* signal mask */
|
|
static sigset_t blocked_sigs;
|
|
|
|
/* signal handling */
|
|
static int work;
|
|
#define WORK_DOINFO 0x0001
|
|
#define WORK_RECONFIG 0x0002
|
|
|
|
/* oids */
|
|
static const struct asn_oid
|
|
oid_snmpMIB = OIDX_snmpMIB,
|
|
oid_begemotSnmpd = OIDX_begemotSnmpd,
|
|
oid_coldStart = OIDX_coldStart,
|
|
oid_authenticationFailure = OIDX_authenticationFailure;
|
|
|
|
const struct asn_oid oid_zeroDotZero = { 2, { 0, 0 }};
|
|
|
|
/* request id generator for traps */
|
|
u_int trap_reqid;
|
|
|
|
/* help text */
|
|
static const char usgtxt[] = "\
|
|
Begemot simple SNMP daemon. Copyright (c) 2001-2002 Fraunhofer Institute for\n\
|
|
Open Communication Systems (FhG Fokus). All rights reserved.\n\
|
|
usage: snmpd [-dh] [-c file] [-D options] [-I path] [-l prefix]\n\
|
|
[-m variable=value] [-p file]\n\
|
|
options:\n\
|
|
-d don't daemonize\n\
|
|
-h print this info\n\
|
|
-c file specify configuration file\n\
|
|
-D options debugging options\n\
|
|
-I path system include path\n\
|
|
-l prefix default basename for pid and config file\n\
|
|
-m var=val define variable\n\
|
|
-p file specify pid file\n\
|
|
";
|
|
|
|
/* hosts_access(3) request */
|
|
#ifdef USE_TCPWRAPPERS
|
|
static struct request_info req;
|
|
#endif
|
|
|
|
/* transports */
|
|
extern const struct transport_def udp_trans;
|
|
extern const struct transport_def lsock_trans;
|
|
|
|
struct transport_list transport_list = TAILQ_HEAD_INITIALIZER(transport_list);
|
|
|
|
/* forward declarations */
|
|
static void snmp_printf_func(const char *fmt, ...);
|
|
static void snmp_error_func(const char *err, ...);
|
|
static void snmp_debug_func(const char *err, ...);
|
|
static void asn_error_func(const struct asn_buf *b, const char *err, ...);
|
|
|
|
/*
|
|
* Allocate rx/tx buffer. We allocate one byte more for rx.
|
|
*/
|
|
void *
|
|
buf_alloc(int tx)
|
|
{
|
|
void *buf;
|
|
|
|
if ((buf = malloc(tx ? snmpd.txbuf : snmpd.rxbuf)) == NULL) {
|
|
syslog(LOG_CRIT, "cannot allocate buffer");
|
|
if (tx)
|
|
snmpd_stats.noTxbuf++;
|
|
else
|
|
snmpd_stats.noRxbuf++;
|
|
return (NULL);
|
|
}
|
|
return (buf);
|
|
}
|
|
|
|
/*
|
|
* Return the buffer size.
|
|
*/
|
|
size_t
|
|
buf_size(int tx)
|
|
{
|
|
return (tx ? snmpd.txbuf : snmpd.rxbuf);
|
|
}
|
|
|
|
/*
|
|
* Prepare a PDU for output
|
|
*/
|
|
void
|
|
snmp_output(struct snmp_pdu *pdu, u_char *sndbuf, size_t *sndlen,
|
|
const char *dest)
|
|
{
|
|
struct asn_buf resp_b;
|
|
|
|
resp_b.asn_ptr = sndbuf;
|
|
resp_b.asn_len = snmpd.txbuf;
|
|
|
|
if (snmp_pdu_encode(pdu, &resp_b) != 0) {
|
|
syslog(LOG_ERR, "cannot encode message");
|
|
abort();
|
|
}
|
|
if (debug.dump_pdus) {
|
|
snmp_printf("%s <- ", dest);
|
|
snmp_pdu_dump(pdu);
|
|
}
|
|
*sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
|
|
}
|
|
|
|
/*
|
|
* SNMP input. Start: decode the PDU, find the community.
|
|
*/
|
|
enum snmpd_input_err
|
|
snmp_input_start(const u_char *buf, size_t len, const char *source,
|
|
struct snmp_pdu *pdu, int32_t *ip, size_t *pdulen)
|
|
{
|
|
struct asn_buf b;
|
|
enum snmp_code code;
|
|
enum snmpd_input_err ret;
|
|
int sret;
|
|
|
|
b.asn_cptr = buf;
|
|
b.asn_len = len;
|
|
|
|
/* look whether we have enough bytes for the entire PDU. */
|
|
switch (sret = snmp_pdu_snoop(&b)) {
|
|
|
|
case 0:
|
|
return (SNMPD_INPUT_TRUNC);
|
|
|
|
case -1:
|
|
snmpd_stats.inASNParseErrs++;
|
|
return (SNMPD_INPUT_FAILED);
|
|
}
|
|
b.asn_len = *pdulen = (size_t)sret;
|
|
|
|
code = snmp_pdu_decode(&b, pdu, ip);
|
|
|
|
snmpd_stats.inPkts++;
|
|
|
|
ret = SNMPD_INPUT_OK;
|
|
switch (code) {
|
|
|
|
case SNMP_CODE_FAILED:
|
|
snmpd_stats.inASNParseErrs++;
|
|
return (SNMPD_INPUT_FAILED);
|
|
|
|
case SNMP_CODE_BADVERS:
|
|
bad_vers:
|
|
snmpd_stats.inBadVersions++;
|
|
return (SNMPD_INPUT_FAILED);
|
|
|
|
case SNMP_CODE_BADLEN:
|
|
if (pdu->type == SNMP_OP_SET)
|
|
ret = SNMPD_INPUT_VALBADLEN;
|
|
break;
|
|
|
|
case SNMP_CODE_OORANGE:
|
|
if (pdu->type == SNMP_OP_SET)
|
|
ret = SNMPD_INPUT_VALRANGE;
|
|
break;
|
|
|
|
case SNMP_CODE_BADENC:
|
|
if (pdu->type == SNMP_OP_SET)
|
|
ret = SNMPD_INPUT_VALBADENC;
|
|
break;
|
|
|
|
case SNMP_CODE_OK:
|
|
switch (pdu->version) {
|
|
|
|
case SNMP_V1:
|
|
if (!(snmpd.version_enable & VERS_ENABLE_V1))
|
|
goto bad_vers;
|
|
break;
|
|
|
|
case SNMP_V2c:
|
|
if (!(snmpd.version_enable & VERS_ENABLE_V2C))
|
|
goto bad_vers;
|
|
break;
|
|
|
|
case SNMP_Verr:
|
|
goto bad_vers;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (debug.dump_pdus) {
|
|
snmp_printf("%s -> ", source);
|
|
snmp_pdu_dump(pdu);
|
|
}
|
|
|
|
/*
|
|
* Look, whether we know the community
|
|
*/
|
|
TAILQ_FOREACH(comm, &community_list, link)
|
|
if (comm->string != NULL &&
|
|
strcmp(comm->string, pdu->community) == 0)
|
|
break;
|
|
|
|
if (comm == NULL) {
|
|
snmpd_stats.inBadCommunityNames++;
|
|
snmp_pdu_free(pdu);
|
|
if (snmpd.auth_traps)
|
|
snmp_send_trap(&oid_authenticationFailure,
|
|
(struct snmp_value *)NULL);
|
|
ret = SNMPD_INPUT_BAD_COMM;
|
|
} else
|
|
community = comm->value;
|
|
|
|
/* update uptime */
|
|
this_tick = get_ticks();
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Will return only _OK or _FAILED
|
|
*/
|
|
enum snmpd_input_err
|
|
snmp_input_finish(struct snmp_pdu *pdu, const u_char *rcvbuf, size_t rcvlen,
|
|
u_char *sndbuf, size_t *sndlen, const char *source,
|
|
enum snmpd_input_err ierr, int32_t ivar, void *data)
|
|
{
|
|
struct snmp_pdu resp;
|
|
struct asn_buf resp_b, pdu_b;
|
|
enum snmp_ret ret;
|
|
|
|
resp_b.asn_ptr = sndbuf;
|
|
resp_b.asn_len = snmpd.txbuf;
|
|
|
|
pdu_b.asn_cptr = rcvbuf;
|
|
pdu_b.asn_len = rcvlen;
|
|
|
|
if (ierr != SNMPD_INPUT_OK) {
|
|
/* error decoding the input of a SET */
|
|
if (pdu->version == SNMP_V1)
|
|
pdu->error_status = SNMP_ERR_BADVALUE;
|
|
else if (ierr == SNMPD_INPUT_VALBADLEN)
|
|
pdu->error_status = SNMP_ERR_WRONG_LENGTH;
|
|
else if (ierr == SNMPD_INPUT_VALRANGE)
|
|
pdu->error_status = SNMP_ERR_WRONG_VALUE;
|
|
else
|
|
pdu->error_status = SNMP_ERR_WRONG_ENCODING;
|
|
|
|
pdu->error_index = ivar;
|
|
|
|
if (snmp_make_errresp(pdu, &pdu_b, &resp_b) == SNMP_RET_IGN) {
|
|
syslog(LOG_WARNING, "could not encode error response");
|
|
snmpd_stats.silentDrops++;
|
|
return (SNMPD_INPUT_FAILED);
|
|
}
|
|
|
|
if (debug.dump_pdus) {
|
|
snmp_printf("%s <- ", source);
|
|
snmp_pdu_dump(pdu);
|
|
}
|
|
*sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
|
|
return (SNMPD_INPUT_OK);
|
|
}
|
|
|
|
switch (pdu->type) {
|
|
|
|
case SNMP_PDU_GET:
|
|
ret = snmp_get(pdu, &resp_b, &resp, data);
|
|
break;
|
|
|
|
case SNMP_PDU_GETNEXT:
|
|
ret = snmp_getnext(pdu, &resp_b, &resp, data);
|
|
break;
|
|
|
|
case SNMP_PDU_SET:
|
|
ret = snmp_set(pdu, &resp_b, &resp, data);
|
|
break;
|
|
|
|
case SNMP_PDU_GETBULK:
|
|
ret = snmp_getbulk(pdu, &resp_b, &resp, data);
|
|
break;
|
|
|
|
default:
|
|
ret = SNMP_RET_IGN;
|
|
break;
|
|
}
|
|
|
|
switch (ret) {
|
|
|
|
case SNMP_RET_OK:
|
|
/* normal return - send a response */
|
|
if (debug.dump_pdus) {
|
|
snmp_printf("%s <- ", source);
|
|
snmp_pdu_dump(&resp);
|
|
}
|
|
*sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
|
|
snmp_pdu_free(&resp);
|
|
return (SNMPD_INPUT_OK);
|
|
|
|
case SNMP_RET_IGN:
|
|
/* error - send nothing */
|
|
snmpd_stats.silentDrops++;
|
|
return (SNMPD_INPUT_FAILED);
|
|
|
|
case SNMP_RET_ERR:
|
|
/* error - send error response. The snmp routine has
|
|
* changed the error fields in the original message. */
|
|
resp_b.asn_ptr = sndbuf;
|
|
resp_b.asn_len = snmpd.txbuf;
|
|
if (snmp_make_errresp(pdu, &pdu_b, &resp_b) == SNMP_RET_IGN) {
|
|
syslog(LOG_WARNING, "could not encode error response");
|
|
snmpd_stats.silentDrops++;
|
|
return (SNMPD_INPUT_FAILED);
|
|
} else {
|
|
if (debug.dump_pdus) {
|
|
snmp_printf("%s <- ", source);
|
|
snmp_pdu_dump(pdu);
|
|
}
|
|
*sndlen = (size_t)(resp_b.asn_ptr - sndbuf);
|
|
return (SNMPD_INPUT_OK);
|
|
}
|
|
}
|
|
abort();
|
|
}
|
|
|
|
/*
|
|
* Insert a port into the right place in the transport's table of ports
|
|
*/
|
|
void
|
|
trans_insert_port(struct transport *t, struct tport *port)
|
|
{
|
|
struct tport *p;
|
|
|
|
TAILQ_FOREACH(p, &t->table, link) {
|
|
if (asn_compare_oid(&p->index, &port->index) > 0) {
|
|
TAILQ_INSERT_BEFORE(p, port, link);
|
|
return;
|
|
}
|
|
}
|
|
port->transport = t;
|
|
TAILQ_INSERT_TAIL(&t->table, port, link);
|
|
}
|
|
|
|
/*
|
|
* Remove a port from a transport's list
|
|
*/
|
|
void
|
|
trans_remove_port(struct tport *port)
|
|
{
|
|
|
|
TAILQ_REMOVE(&port->transport->table, port, link);
|
|
}
|
|
|
|
/*
|
|
* Find a port on a transport's list
|
|
*/
|
|
struct tport *
|
|
trans_find_port(struct transport *t, const struct asn_oid *idx, u_int sub)
|
|
{
|
|
|
|
return (FIND_OBJECT_OID(&t->table, idx, sub));
|
|
}
|
|
|
|
/*
|
|
* Find next port on a transport's list
|
|
*/
|
|
struct tport *
|
|
trans_next_port(struct transport *t, const struct asn_oid *idx, u_int sub)
|
|
{
|
|
|
|
return (NEXT_OBJECT_OID(&t->table, idx, sub));
|
|
}
|
|
|
|
/*
|
|
* Return first port
|
|
*/
|
|
struct tport *
|
|
trans_first_port(struct transport *t)
|
|
{
|
|
|
|
return (TAILQ_FIRST(&t->table));
|
|
}
|
|
|
|
/*
|
|
* Iterate through all ports until a function returns a 0.
|
|
*/
|
|
struct tport *
|
|
trans_iter_port(struct transport *t, int (*func)(struct tport *, intptr_t),
|
|
intptr_t arg)
|
|
{
|
|
struct tport *p;
|
|
|
|
TAILQ_FOREACH(p, &t->table, link)
|
|
if (func(p, arg) == 0)
|
|
return (p);
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Register a transport
|
|
*/
|
|
int
|
|
trans_register(const struct transport_def *def, struct transport **pp)
|
|
{
|
|
u_int i;
|
|
char or_descr[256];
|
|
|
|
if ((*pp = malloc(sizeof(**pp))) == NULL)
|
|
return (SNMP_ERR_GENERR);
|
|
|
|
/* construct index */
|
|
(*pp)->index.len = strlen(def->name) + 1;
|
|
(*pp)->index.subs[0] = strlen(def->name);
|
|
for (i = 0; i < (*pp)->index.subs[0]; i++)
|
|
(*pp)->index.subs[i + 1] = def->name[i];
|
|
|
|
(*pp)->vtab = def;
|
|
|
|
if (FIND_OBJECT_OID(&transport_list, &(*pp)->index, 0) != NULL) {
|
|
free(*pp);
|
|
return (SNMP_ERR_INCONS_VALUE);
|
|
}
|
|
|
|
/* register module */
|
|
snprintf(or_descr, sizeof(or_descr), "%s transport mapping", def->name);
|
|
if (((*pp)->or_index = or_register(&def->id, or_descr, NULL)) == 0) {
|
|
free(*pp);
|
|
return (SNMP_ERR_GENERR);
|
|
}
|
|
|
|
INSERT_OBJECT_OID((*pp), &transport_list);
|
|
|
|
TAILQ_INIT(&(*pp)->table);
|
|
|
|
return (SNMP_ERR_NOERROR);
|
|
}
|
|
|
|
/*
|
|
* Unregister transport
|
|
*/
|
|
int
|
|
trans_unregister(struct transport *t)
|
|
{
|
|
if (!TAILQ_EMPTY(&t->table))
|
|
return (SNMP_ERR_INCONS_VALUE);
|
|
|
|
or_unregister(t->or_index);
|
|
TAILQ_REMOVE(&transport_list, t, link);
|
|
|
|
return (SNMP_ERR_NOERROR);
|
|
}
|
|
|
|
/*
|
|
* File descriptor support
|
|
*/
|
|
#ifdef USE_LIBBEGEMOT
|
|
static void
|
|
input(int fd, int mask __unused, void *uap)
|
|
#else
|
|
static void
|
|
input(evContext ctx __unused, void *uap, int fd, int mask __unused)
|
|
#endif
|
|
{
|
|
struct fdesc *f = uap;
|
|
|
|
(*f->func)(fd, f->udata);
|
|
}
|
|
|
|
void
|
|
fd_suspend(void *p)
|
|
{
|
|
struct fdesc *f = p;
|
|
|
|
#ifdef USE_LIBBEGEMOT
|
|
if (f->id >= 0) {
|
|
poll_unregister(f->id);
|
|
f->id = -1;
|
|
}
|
|
#else
|
|
if (evTestID(f->id)) {
|
|
(void)evDeselectFD(evctx, f->id);
|
|
evInitID(&f->id);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
int
|
|
fd_resume(void *p)
|
|
{
|
|
struct fdesc *f = p;
|
|
int err;
|
|
|
|
#ifdef USE_LIBBEGEMOT
|
|
if (f->id >= 0)
|
|
return (0);
|
|
if ((f->id = poll_register(f->fd, input, f, POLL_IN)) < 0) {
|
|
err = errno;
|
|
syslog(LOG_ERR, "select fd %d: %m", f->fd);
|
|
errno = err;
|
|
return (-1);
|
|
}
|
|
#else
|
|
if (evTestID(f->id))
|
|
return (0);
|
|
if (evSelectFD(evctx, f->fd, EV_READ, input, f, &f->id)) {
|
|
err = errno;
|
|
syslog(LOG_ERR, "select fd %d: %m", f->fd);
|
|
errno = err;
|
|
return (-1);
|
|
}
|
|
#endif
|
|
return (0);
|
|
}
|
|
|
|
void *
|
|
fd_select(int fd, void (*func)(int, void *), void *udata, struct lmodule *mod)
|
|
{
|
|
struct fdesc *f;
|
|
int err;
|
|
|
|
if ((f = malloc(sizeof(struct fdesc))) == NULL) {
|
|
err = errno;
|
|
syslog(LOG_ERR, "fd_select: %m");
|
|
errno = err;
|
|
return (NULL);
|
|
}
|
|
f->fd = fd;
|
|
f->func = func;
|
|
f->udata = udata;
|
|
f->owner = mod;
|
|
#ifdef USE_LIBBEGEMOT
|
|
f->id = -1;
|
|
#else
|
|
evInitID(&f->id);
|
|
#endif
|
|
|
|
if (fd_resume(f)) {
|
|
err = errno;
|
|
free(f);
|
|
errno = err;
|
|
return (NULL);
|
|
}
|
|
|
|
LIST_INSERT_HEAD(&fdesc_list, f, link);
|
|
|
|
return (f);
|
|
}
|
|
|
|
void
|
|
fd_deselect(void *p)
|
|
{
|
|
struct fdesc *f = p;
|
|
|
|
LIST_REMOVE(f, link);
|
|
fd_suspend(f);
|
|
free(f);
|
|
}
|
|
|
|
static void
|
|
fd_flush(struct lmodule *mod)
|
|
{
|
|
struct fdesc *t, *t1;
|
|
|
|
t = LIST_FIRST(&fdesc_list);
|
|
while (t != NULL) {
|
|
t1 = LIST_NEXT(t, link);
|
|
if (t->owner == mod)
|
|
fd_deselect(t);
|
|
t = t1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Consume a message from the input buffer
|
|
*/
|
|
static void
|
|
snmp_input_consume(struct port_input *pi)
|
|
{
|
|
if (!pi->stream) {
|
|
/* always consume everything */
|
|
pi->length = 0;
|
|
return;
|
|
}
|
|
if (pi->consumed >= pi->length) {
|
|
/* all bytes consumed */
|
|
pi->length = 0;
|
|
return;
|
|
}
|
|
memmove(pi->buf, pi->buf + pi->consumed, pi->length - pi->consumed);
|
|
pi->length -= pi->consumed;
|
|
}
|
|
|
|
struct credmsg {
|
|
struct cmsghdr hdr;
|
|
struct cmsgcred cred;
|
|
};
|
|
|
|
static void
|
|
check_priv(struct port_input *pi, struct msghdr *msg)
|
|
{
|
|
struct credmsg *cmsg;
|
|
struct xucred ucred;
|
|
socklen_t ucredlen;
|
|
|
|
pi->priv = 0;
|
|
|
|
if (msg->msg_controllen == sizeof(*cmsg)) {
|
|
/* process explicitly sends credentials */
|
|
|
|
cmsg = (struct credmsg *)msg->msg_control;
|
|
pi->priv = (cmsg->cred.cmcred_euid == 0);
|
|
return;
|
|
}
|
|
|
|
/* ok, obtain the accept time credentials */
|
|
ucredlen = sizeof(ucred);
|
|
|
|
if (getsockopt(pi->fd, 0, LOCAL_PEERCRED, &ucred, &ucredlen) == 0 &&
|
|
ucredlen >= sizeof(ucred) && ucred.cr_version == XUCRED_VERSION)
|
|
pi->priv = (ucred.cr_uid == 0);
|
|
}
|
|
|
|
/*
|
|
* Input from a stream socket.
|
|
*/
|
|
static int
|
|
recv_stream(struct port_input *pi)
|
|
{
|
|
struct msghdr msg;
|
|
struct iovec iov[1];
|
|
ssize_t len;
|
|
struct credmsg cmsg;
|
|
|
|
if (pi->buf == NULL) {
|
|
/* no buffer yet - allocate one */
|
|
if ((pi->buf = buf_alloc(0)) == NULL) {
|
|
/* ups - could not get buffer. Return an error
|
|
* the caller must close the transport. */
|
|
return (-1);
|
|
}
|
|
pi->buflen = buf_size(0);
|
|
pi->consumed = 0;
|
|
pi->length = 0;
|
|
}
|
|
|
|
/* try to get a message */
|
|
msg.msg_name = pi->peer;
|
|
msg.msg_namelen = pi->peerlen;
|
|
msg.msg_iov = iov;
|
|
msg.msg_iovlen = 1;
|
|
if (pi->cred) {
|
|
msg.msg_control = &cmsg;
|
|
msg.msg_controllen = sizeof(cmsg);
|
|
|
|
cmsg.hdr.cmsg_len = sizeof(cmsg);
|
|
cmsg.hdr.cmsg_level = SOL_SOCKET;
|
|
cmsg.hdr.cmsg_type = SCM_CREDS;
|
|
} else {
|
|
msg.msg_control = NULL;
|
|
msg.msg_controllen = 0;
|
|
}
|
|
msg.msg_flags = 0;
|
|
|
|
iov[0].iov_base = pi->buf + pi->length;
|
|
iov[0].iov_len = pi->buflen - pi->length;
|
|
|
|
len = recvmsg(pi->fd, &msg, 0);
|
|
|
|
if (len == -1 || len == 0)
|
|
/* receive error */
|
|
return (-1);
|
|
|
|
pi->length += len;
|
|
|
|
if (pi->cred)
|
|
check_priv(pi, &msg);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Input from a datagram socket.
|
|
* Each receive should return one datagram.
|
|
*/
|
|
static int
|
|
recv_dgram(struct port_input *pi)
|
|
{
|
|
u_char embuf[1000];
|
|
struct msghdr msg;
|
|
struct iovec iov[1];
|
|
ssize_t len;
|
|
struct credmsg cmsg;
|
|
|
|
if (pi->buf == NULL) {
|
|
/* no buffer yet - allocate one */
|
|
if ((pi->buf = buf_alloc(0)) == NULL) {
|
|
/* ups - could not get buffer. Read away input
|
|
* and drop it */
|
|
(void)recvfrom(pi->fd, embuf, sizeof(embuf),
|
|
0, NULL, NULL);
|
|
/* return error */
|
|
return (-1);
|
|
}
|
|
pi->buflen = buf_size(0);
|
|
}
|
|
|
|
/* try to get a message */
|
|
msg.msg_name = pi->peer;
|
|
msg.msg_namelen = pi->peerlen;
|
|
msg.msg_iov = iov;
|
|
msg.msg_iovlen = 1;
|
|
if (pi->cred) {
|
|
msg.msg_control = &cmsg;
|
|
msg.msg_controllen = sizeof(cmsg);
|
|
|
|
cmsg.hdr.cmsg_len = sizeof(cmsg);
|
|
cmsg.hdr.cmsg_level = SOL_SOCKET;
|
|
cmsg.hdr.cmsg_type = SCM_CREDS;
|
|
} else {
|
|
msg.msg_control = NULL;
|
|
msg.msg_controllen = 0;
|
|
}
|
|
msg.msg_flags = 0;
|
|
|
|
iov[0].iov_base = pi->buf;
|
|
iov[0].iov_len = pi->buflen;
|
|
|
|
len = recvmsg(pi->fd, &msg, 0);
|
|
|
|
if (len == -1 || len == 0)
|
|
/* receive error */
|
|
return (-1);
|
|
|
|
if (msg.msg_flags & MSG_TRUNC) {
|
|
/* truncated - drop */
|
|
snmpd_stats.silentDrops++;
|
|
snmpd_stats.inTooLong++;
|
|
return (-1);
|
|
}
|
|
|
|
pi->length = (size_t)len;
|
|
|
|
if (pi->cred)
|
|
check_priv(pi, &msg);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Input from a socket
|
|
*/
|
|
int
|
|
snmpd_input(struct port_input *pi, struct tport *tport)
|
|
{
|
|
u_char *sndbuf;
|
|
size_t sndlen;
|
|
struct snmp_pdu pdu;
|
|
enum snmpd_input_err ierr, ferr;
|
|
enum snmpd_proxy_err perr;
|
|
int32_t vi;
|
|
int ret;
|
|
ssize_t slen;
|
|
#ifdef USE_TCPWRAPPERS
|
|
char client[16];
|
|
#endif
|
|
|
|
/* get input depending on the transport */
|
|
if (pi->stream) {
|
|
ret = recv_stream(pi);
|
|
} else {
|
|
ret = recv_dgram(pi);
|
|
}
|
|
|
|
if (ret == -1)
|
|
return (-1);
|
|
|
|
#ifdef USE_TCPWRAPPERS
|
|
/*
|
|
* In case of AF_INET{6} peer, do hosts_access(5) check.
|
|
*/
|
|
if (inet_ntop(pi->peer->sa_family,
|
|
&((const struct sockaddr_in *)(const void *)pi->peer)->sin_addr,
|
|
client, sizeof(client)) != NULL) {
|
|
request_set(&req, RQ_CLIENT_ADDR, client, 0);
|
|
if (hosts_access(&req) == 0) {
|
|
syslog(LOG_ERR, "refused connection from %.500s",
|
|
eval_client(&req));
|
|
return (-1);
|
|
}
|
|
} else
|
|
syslog(LOG_ERR, "inet_ntop(): %m");
|
|
#endif
|
|
|
|
/*
|
|
* Handle input
|
|
*/
|
|
ierr = snmp_input_start(pi->buf, pi->length, "SNMP", &pdu, &vi,
|
|
&pi->consumed);
|
|
if (ierr == SNMPD_INPUT_TRUNC) {
|
|
/* need more bytes. This is ok only for streaming transports.
|
|
* but only if we have not reached bufsiz yet. */
|
|
if (pi->stream) {
|
|
if (pi->length == buf_size(0)) {
|
|
snmpd_stats.silentDrops++;
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
snmpd_stats.silentDrops++;
|
|
return (-1);
|
|
}
|
|
|
|
/* can't check for bad SET pdus here, because a proxy may have to
|
|
* check the access first. We don't want to return an error response
|
|
* to a proxy PDU with a wrong community */
|
|
if (ierr == SNMPD_INPUT_FAILED) {
|
|
/* for streaming transports this is fatal */
|
|
if (pi->stream)
|
|
return (-1);
|
|
snmp_input_consume(pi);
|
|
return (0);
|
|
}
|
|
if (ierr == SNMPD_INPUT_BAD_COMM) {
|
|
snmp_input_consume(pi);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* If that is a module community and the module has a proxy function,
|
|
* the hand it over to the module.
|
|
*/
|
|
if (comm->owner != NULL && comm->owner->config->proxy != NULL) {
|
|
perr = (*comm->owner->config->proxy)(&pdu, tport->transport,
|
|
&tport->index, pi->peer, pi->peerlen, ierr, vi,
|
|
!pi->cred || pi->priv);
|
|
|
|
switch (perr) {
|
|
|
|
case SNMPD_PROXY_OK:
|
|
snmp_input_consume(pi);
|
|
return (0);
|
|
|
|
case SNMPD_PROXY_REJ:
|
|
break;
|
|
|
|
case SNMPD_PROXY_DROP:
|
|
snmp_input_consume(pi);
|
|
snmp_pdu_free(&pdu);
|
|
snmpd_stats.proxyDrops++;
|
|
return (0);
|
|
|
|
case SNMPD_PROXY_BADCOMM:
|
|
snmp_input_consume(pi);
|
|
snmp_pdu_free(&pdu);
|
|
snmpd_stats.inBadCommunityNames++;
|
|
if (snmpd.auth_traps)
|
|
snmp_send_trap(&oid_authenticationFailure,
|
|
(struct snmp_value *)NULL);
|
|
return (0);
|
|
|
|
case SNMPD_PROXY_BADCOMMUSE:
|
|
snmp_input_consume(pi);
|
|
snmp_pdu_free(&pdu);
|
|
snmpd_stats.inBadCommunityUses++;
|
|
if (snmpd.auth_traps)
|
|
snmp_send_trap(&oid_authenticationFailure,
|
|
(struct snmp_value *)NULL);
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check type
|
|
*/
|
|
if (pdu.type == SNMP_PDU_RESPONSE ||
|
|
pdu.type == SNMP_PDU_TRAP ||
|
|
pdu.type == SNMP_PDU_TRAP2) {
|
|
snmpd_stats.silentDrops++;
|
|
snmpd_stats.inBadPduTypes++;
|
|
snmp_pdu_free(&pdu);
|
|
snmp_input_consume(pi);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Check community
|
|
*/
|
|
if ((pi->cred && !pi->priv && pdu.type == SNMP_PDU_SET) ||
|
|
(community != COMM_WRITE &&
|
|
(pdu.type == SNMP_PDU_SET || community != COMM_READ))) {
|
|
snmpd_stats.inBadCommunityUses++;
|
|
snmp_pdu_free(&pdu);
|
|
snmp_input_consume(pi);
|
|
if (snmpd.auth_traps)
|
|
snmp_send_trap(&oid_authenticationFailure,
|
|
(struct snmp_value *)NULL);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Execute it.
|
|
*/
|
|
if ((sndbuf = buf_alloc(1)) == NULL) {
|
|
snmpd_stats.silentDrops++;
|
|
snmp_pdu_free(&pdu);
|
|
snmp_input_consume(pi);
|
|
return (0);
|
|
}
|
|
ferr = snmp_input_finish(&pdu, pi->buf, pi->length,
|
|
sndbuf, &sndlen, "SNMP", ierr, vi, NULL);
|
|
|
|
if (ferr == SNMPD_INPUT_OK) {
|
|
slen = sendto(pi->fd, sndbuf, sndlen, 0, pi->peer, pi->peerlen);
|
|
if (slen == -1)
|
|
syslog(LOG_ERR, "sendto: %m");
|
|
else if ((size_t)slen != sndlen)
|
|
syslog(LOG_ERR, "sendto: short write %zu/%zu",
|
|
sndlen, (size_t)slen);
|
|
}
|
|
snmp_pdu_free(&pdu);
|
|
free(sndbuf);
|
|
snmp_input_consume(pi);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Send a PDU to a given port
|
|
*/
|
|
void
|
|
snmp_send_port(void *targ, const struct asn_oid *port, struct snmp_pdu *pdu,
|
|
const struct sockaddr *addr, socklen_t addrlen)
|
|
{
|
|
struct transport *trans = targ;
|
|
struct tport *tp;
|
|
u_char *sndbuf;
|
|
size_t sndlen;
|
|
ssize_t len;
|
|
|
|
TAILQ_FOREACH(tp, &trans->table, link)
|
|
if (asn_compare_oid(port, &tp->index) == 0)
|
|
break;
|
|
if (tp == 0)
|
|
return;
|
|
|
|
if ((sndbuf = buf_alloc(1)) == NULL)
|
|
return;
|
|
|
|
snmp_output(pdu, sndbuf, &sndlen, "SNMP PROXY");
|
|
|
|
len = trans->vtab->send(tp, sndbuf, sndlen, addr, addrlen);
|
|
|
|
if (len == -1)
|
|
syslog(LOG_ERR, "sendto: %m");
|
|
else if ((size_t)len != sndlen)
|
|
syslog(LOG_ERR, "sendto: short write %zu/%zu",
|
|
sndlen, (size_t)len);
|
|
|
|
free(sndbuf);
|
|
}
|
|
|
|
|
|
/*
|
|
* Close an input source
|
|
*/
|
|
void
|
|
snmpd_input_close(struct port_input *pi)
|
|
{
|
|
if (pi->id != NULL)
|
|
fd_deselect(pi->id);
|
|
if (pi->fd >= 0)
|
|
(void)close(pi->fd);
|
|
if (pi->buf != NULL)
|
|
free(pi->buf);
|
|
}
|
|
|
|
/*
|
|
* Dump internal state.
|
|
*/
|
|
#ifdef USE_LIBBEGEMOT
|
|
static void
|
|
info_func(void)
|
|
#else
|
|
static void
|
|
info_func(evContext ctx __unused, void *uap __unused, const void *tag __unused)
|
|
#endif
|
|
{
|
|
struct lmodule *m;
|
|
u_int i;
|
|
char buf[10000];
|
|
|
|
syslog(LOG_DEBUG, "Dump of SNMPd %lu\n", (u_long)getpid());
|
|
for (i = 0; i < tree_size; i++) {
|
|
switch (tree[i].type) {
|
|
|
|
case SNMP_NODE_LEAF:
|
|
sprintf(buf, "LEAF: %s %s", tree[i].name,
|
|
asn_oid2str(&tree[i].oid));
|
|
break;
|
|
|
|
case SNMP_NODE_COLUMN:
|
|
sprintf(buf, "COL: %s %s", tree[i].name,
|
|
asn_oid2str(&tree[i].oid));
|
|
break;
|
|
}
|
|
syslog(LOG_DEBUG, "%s", buf);
|
|
}
|
|
|
|
TAILQ_FOREACH(m, &lmodules, link)
|
|
if (m->config->dump)
|
|
(*m->config->dump)();
|
|
}
|
|
|
|
/*
|
|
* Re-read configuration
|
|
*/
|
|
#ifdef USE_LIBBEGEMOT
|
|
static void
|
|
config_func(void)
|
|
#else
|
|
static void
|
|
config_func(evContext ctx __unused, void *uap __unused,
|
|
const void *tag __unused)
|
|
#endif
|
|
{
|
|
struct lmodule *m;
|
|
|
|
if (read_config(config_file, NULL)) {
|
|
syslog(LOG_ERR, "error reading config file '%s'", config_file);
|
|
return;
|
|
}
|
|
TAILQ_FOREACH(m, &lmodules, link)
|
|
if (m->config->config)
|
|
(*m->config->config)();
|
|
}
|
|
|
|
/*
|
|
* On USR1 dump actual configuration.
|
|
*/
|
|
static void
|
|
onusr1(int s __unused)
|
|
{
|
|
|
|
work |= WORK_DOINFO;
|
|
}
|
|
static void
|
|
onhup(int s __unused)
|
|
{
|
|
|
|
work |= WORK_RECONFIG;
|
|
}
|
|
|
|
static void
|
|
onterm(int s __unused)
|
|
{
|
|
|
|
/* allow clean-up */
|
|
exit(0);
|
|
}
|
|
|
|
static void
|
|
init_sigs(void)
|
|
{
|
|
struct sigaction sa;
|
|
|
|
sa.sa_handler = onusr1;
|
|
sa.sa_flags = SA_RESTART;
|
|
sigemptyset(&sa.sa_mask);
|
|
if (sigaction(SIGUSR1, &sa, NULL)) {
|
|
syslog(LOG_ERR, "sigaction: %m");
|
|
exit(1);
|
|
}
|
|
|
|
sa.sa_handler = onhup;
|
|
if (sigaction(SIGHUP, &sa, NULL)) {
|
|
syslog(LOG_ERR, "sigaction: %m");
|
|
exit(1);
|
|
}
|
|
|
|
sa.sa_handler = onterm;
|
|
sa.sa_flags = 0;
|
|
sigemptyset(&sa.sa_mask);
|
|
if (sigaction(SIGTERM, &sa, NULL)) {
|
|
syslog(LOG_ERR, "sigaction: %m");
|
|
exit(1);
|
|
}
|
|
if (sigaction(SIGINT, &sa, NULL)) {
|
|
syslog(LOG_ERR, "sigaction: %m");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
block_sigs(void)
|
|
{
|
|
sigset_t set;
|
|
|
|
sigfillset(&set);
|
|
if (sigprocmask(SIG_BLOCK, &set, &blocked_sigs) == -1) {
|
|
syslog(LOG_ERR, "SIG_BLOCK: %m");
|
|
exit(1);
|
|
}
|
|
}
|
|
static void
|
|
unblock_sigs(void)
|
|
{
|
|
if (sigprocmask(SIG_SETMASK, &blocked_sigs, NULL) == -1) {
|
|
syslog(LOG_ERR, "SIG_SETMASK: %m");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Shut down
|
|
*/
|
|
static void
|
|
term(void)
|
|
{
|
|
(void)unlink(pid_file);
|
|
}
|
|
|
|
static void
|
|
trans_stop(void)
|
|
{
|
|
struct transport *t;
|
|
|
|
TAILQ_FOREACH(t, &transport_list, link)
|
|
(void)t->vtab->stop(1);
|
|
}
|
|
|
|
/*
|
|
* Define a macro from the command line
|
|
*/
|
|
static void
|
|
do_macro(char *arg)
|
|
{
|
|
char *eq;
|
|
int err;
|
|
|
|
if ((eq = strchr(arg, '=')) == NULL)
|
|
err = define_macro(arg, "");
|
|
else {
|
|
*eq++ = '\0';
|
|
err = define_macro(arg, eq);
|
|
}
|
|
if (err == -1) {
|
|
syslog(LOG_ERR, "cannot save macro: %m");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Re-implement getsubopt from scratch, because the second argument is broken
|
|
* and will not compile with WARNS=5.
|
|
*/
|
|
static int
|
|
getsubopt1(char **arg, const char *const *options, char **valp, char **optp)
|
|
{
|
|
static const char *const delim = ",\t ";
|
|
u_int i;
|
|
char *ptr;
|
|
|
|
*optp = NULL;
|
|
|
|
/* skip leading junk */
|
|
for (ptr = *arg; *ptr != '\0'; ptr++)
|
|
if (strchr(delim, *ptr) == NULL)
|
|
break;
|
|
if (*ptr == '\0') {
|
|
*arg = ptr;
|
|
return (-1);
|
|
}
|
|
*optp = ptr;
|
|
|
|
/* find the end of the option */
|
|
while (*++ptr != '\0')
|
|
if (strchr(delim, *ptr) != NULL || *ptr == '=')
|
|
break;
|
|
|
|
if (*ptr != '\0') {
|
|
if (*ptr == '=') {
|
|
*ptr++ = '\0';
|
|
*valp = ptr;
|
|
while (*ptr != '\0' && strchr(delim, *ptr) == NULL)
|
|
ptr++;
|
|
if (*ptr != '\0')
|
|
*ptr++ = '\0';
|
|
} else
|
|
*ptr++ = '\0';
|
|
}
|
|
|
|
*arg = ptr;
|
|
|
|
for (i = 0; *options != NULL; options++, i++)
|
|
if (strcmp(*optp, *options) == 0)
|
|
return (i);
|
|
return (-1);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int opt;
|
|
FILE *fp;
|
|
int background = 1;
|
|
struct tport *p;
|
|
const char *prefix = "snmpd";
|
|
struct lmodule *m;
|
|
char *value, *option;
|
|
struct transport *t;
|
|
|
|
#define DBG_DUMP 0
|
|
#define DBG_EVENTS 1
|
|
#define DBG_TRACE 2
|
|
static const char *const debug_opts[] = {
|
|
"dump",
|
|
"events",
|
|
"trace",
|
|
NULL
|
|
};
|
|
|
|
snmp_printf = snmp_printf_func;
|
|
snmp_error = snmp_error_func;
|
|
snmp_debug = snmp_debug_func;
|
|
asn_error = asn_error_func;
|
|
|
|
while ((opt = getopt(argc, argv, "c:dD:hI:l:m:p:")) != EOF)
|
|
switch (opt) {
|
|
|
|
case 'c':
|
|
strlcpy(config_file, optarg, sizeof(config_file));
|
|
break;
|
|
|
|
case 'd':
|
|
background = 0;
|
|
break;
|
|
|
|
case 'D':
|
|
while (*optarg) {
|
|
switch (getsubopt1(&optarg, debug_opts,
|
|
&value, &option)) {
|
|
|
|
case DBG_DUMP:
|
|
debug.dump_pdus = 1;
|
|
break;
|
|
|
|
case DBG_EVENTS:
|
|
debug.evdebug++;
|
|
break;
|
|
|
|
case DBG_TRACE:
|
|
if (value == NULL)
|
|
syslog(LOG_ERR,
|
|
"no value for 'trace'");
|
|
snmp_trace = strtoul(value, NULL, 0);
|
|
break;
|
|
|
|
case -1:
|
|
if (suboptarg)
|
|
syslog(LOG_ERR,
|
|
"unknown debug flag '%s'",
|
|
option);
|
|
else
|
|
syslog(LOG_ERR,
|
|
"missing debug flag");
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'h':
|
|
fprintf(stderr, "%s", usgtxt);
|
|
exit(0);
|
|
|
|
case 'I':
|
|
syspath = optarg;
|
|
break;
|
|
|
|
case 'l':
|
|
prefix = optarg;
|
|
break;
|
|
|
|
case 'm':
|
|
do_macro(optarg);
|
|
break;
|
|
|
|
case 'p':
|
|
strlcpy(pid_file, optarg, sizeof(pid_file));
|
|
break;
|
|
}
|
|
|
|
openlog(prefix, LOG_PID | (background ? 0 : LOG_PERROR), LOG_USER);
|
|
setlogmask(LOG_UPTO(debug.logpri - 1));
|
|
|
|
if (background && daemon(0, 0) < 0) {
|
|
syslog(LOG_ERR, "daemon: %m");
|
|
exit(1);
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
progargs = argv;
|
|
nprogargs = argc;
|
|
|
|
srandomdev();
|
|
|
|
snmp_serial_no = random();
|
|
|
|
#ifdef USE_TCPWRAPPERS
|
|
/*
|
|
* Initialize hosts_access(3) handler.
|
|
*/
|
|
request_init(&req, RQ_DAEMON, "snmpd", 0);
|
|
sock_methods(&req);
|
|
#endif
|
|
|
|
/*
|
|
* Initialize the tree.
|
|
*/
|
|
if ((tree = malloc(sizeof(struct snmp_node) * CTREE_SIZE)) == NULL) {
|
|
syslog(LOG_ERR, "%m");
|
|
exit(1);
|
|
}
|
|
memcpy(tree, ctree, sizeof(struct snmp_node) * CTREE_SIZE);
|
|
tree_size = CTREE_SIZE;
|
|
|
|
/*
|
|
* Get standard communities
|
|
*/
|
|
(void)comm_define(1, "SNMP read", NULL, NULL);
|
|
(void)comm_define(2, "SNMP write", NULL, NULL);
|
|
community = COMM_INITIALIZE;
|
|
|
|
trap_reqid = reqid_allocate(512, NULL);
|
|
|
|
if (config_file[0] == '\0')
|
|
snprintf(config_file, sizeof(config_file), PATH_CONFIG, prefix);
|
|
|
|
init_actvals();
|
|
|
|
this_tick = get_ticks();
|
|
start_tick = this_tick;
|
|
|
|
/* start transports */
|
|
if (atexit(trans_stop) == -1) {
|
|
syslog(LOG_ERR, "atexit failed: %m");
|
|
exit(1);
|
|
}
|
|
if (udp_trans.start() != SNMP_ERR_NOERROR)
|
|
syslog(LOG_WARNING, "cannot start UDP transport");
|
|
if (lsock_trans.start() != SNMP_ERR_NOERROR)
|
|
syslog(LOG_WARNING, "cannot start LSOCK transport");
|
|
|
|
#ifdef USE_LIBBEGEMOT
|
|
if (debug.evdebug > 0)
|
|
rpoll_trace = 1;
|
|
#else
|
|
if (evCreate(&evctx)) {
|
|
syslog(LOG_ERR, "evCreate: %m");
|
|
exit(1);
|
|
}
|
|
if (debug.evdebug > 0)
|
|
evSetDebug(evctx, 10, stderr);
|
|
#endif
|
|
|
|
if (read_config(config_file, NULL)) {
|
|
syslog(LOG_ERR, "error in config file");
|
|
exit(1);
|
|
}
|
|
|
|
TAILQ_FOREACH(t, &transport_list, link)
|
|
TAILQ_FOREACH(p, &t->table, link)
|
|
t->vtab->init_port(p);
|
|
|
|
init_sigs();
|
|
|
|
if (pid_file[0] == '\0')
|
|
snprintf(pid_file, sizeof(pid_file), PATH_PID, prefix);
|
|
|
|
if ((fp = fopen(pid_file, "w")) != NULL) {
|
|
fprintf(fp, "%u", getpid());
|
|
fclose(fp);
|
|
if (atexit(term) == -1) {
|
|
syslog(LOG_ERR, "atexit failed: %m");
|
|
(void)remove(pid_file);
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
if (or_register(&oid_snmpMIB, "The MIB module for SNMPv2 entities.",
|
|
NULL) == 0) {
|
|
syslog(LOG_ERR, "cannot register SNMPv2 MIB");
|
|
exit(1);
|
|
}
|
|
if (or_register(&oid_begemotSnmpd, "The MIB module for the Begemot SNMPd.",
|
|
NULL) == 0) {
|
|
syslog(LOG_ERR, "cannot register begemotSnmpd MIB");
|
|
exit(1);
|
|
}
|
|
|
|
snmp_send_trap(&oid_coldStart, (struct snmp_value *)NULL);
|
|
|
|
while ((m = TAILQ_FIRST(&modules_start)) != NULL) {
|
|
m->flags &= ~LM_ONSTARTLIST;
|
|
TAILQ_REMOVE(&modules_start, m, start);
|
|
lm_start(m);
|
|
}
|
|
|
|
for (;;) {
|
|
#ifndef USE_LIBBEGEMOT
|
|
evEvent event;
|
|
#endif
|
|
struct lmodule *mod;
|
|
|
|
TAILQ_FOREACH(mod, &lmodules, link)
|
|
if (mod->config->idle != NULL)
|
|
(*mod->config->idle)();
|
|
|
|
#ifndef USE_LIBBEGEMOT
|
|
if (evGetNext(evctx, &event, EV_WAIT) == 0) {
|
|
if (evDispatch(evctx, event))
|
|
syslog(LOG_ERR, "evDispatch: %m");
|
|
} else if (errno != EINTR) {
|
|
syslog(LOG_ERR, "evGetNext: %m");
|
|
exit(1);
|
|
}
|
|
#else
|
|
poll_dispatch(1);
|
|
#endif
|
|
|
|
if (work != 0) {
|
|
block_sigs();
|
|
if (work & WORK_DOINFO) {
|
|
#ifdef USE_LIBBEGEMOT
|
|
info_func();
|
|
#else
|
|
if (evWaitFor(evctx, &work, info_func,
|
|
NULL, NULL) == -1) {
|
|
syslog(LOG_ERR, "evWaitFor: %m");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
}
|
|
if (work & WORK_RECONFIG) {
|
|
#ifdef USE_LIBBEGEMOT
|
|
config_func();
|
|
#else
|
|
if (evWaitFor(evctx, &work, config_func,
|
|
NULL, NULL) == -1) {
|
|
syslog(LOG_ERR, "evWaitFor: %m");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
}
|
|
work = 0;
|
|
unblock_sigs();
|
|
#ifndef USE_LIBBEGEMOT
|
|
if (evDo(evctx, &work) == -1) {
|
|
syslog(LOG_ERR, "evDo: %m");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
uint64_t
|
|
get_ticks()
|
|
{
|
|
struct timeval tv;
|
|
uint64_t ret;
|
|
|
|
if (gettimeofday(&tv, NULL))
|
|
abort();
|
|
ret = tv.tv_sec * 100ULL + tv.tv_usec / 10000ULL;
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Timer support
|
|
*/
|
|
|
|
/*
|
|
* Trampoline for the non-repeatable timers.
|
|
*/
|
|
#ifdef USE_LIBBEGEMOT
|
|
static void
|
|
tfunc(int tid __unused, void *uap)
|
|
#else
|
|
static void
|
|
tfunc(evContext ctx __unused, void *uap, struct timespec due __unused,
|
|
struct timespec inter __unused)
|
|
#endif
|
|
{
|
|
struct timer *tp = uap;
|
|
|
|
LIST_REMOVE(tp, link);
|
|
tp->func(tp->udata);
|
|
free(tp);
|
|
}
|
|
|
|
/*
|
|
* Trampoline for the repeatable timers.
|
|
*/
|
|
#ifdef USE_LIBBEGEMOT
|
|
static void
|
|
trfunc(int tid __unused, void *uap)
|
|
#else
|
|
static void
|
|
trfunc(evContext ctx __unused, void *uap, struct timespec due __unused,
|
|
struct timespec inter __unused)
|
|
#endif
|
|
{
|
|
struct timer *tp = uap;
|
|
|
|
tp->func(tp->udata);
|
|
}
|
|
|
|
/*
|
|
* Start a one-shot timer
|
|
*/
|
|
void *
|
|
timer_start(u_int ticks, void (*func)(void *), void *udata, struct lmodule *mod)
|
|
{
|
|
struct timer *tp;
|
|
#ifndef USE_LIBBEGEMOT
|
|
struct timespec due;
|
|
#endif
|
|
|
|
if ((tp = malloc(sizeof(struct timer))) == NULL) {
|
|
syslog(LOG_CRIT, "out of memory for timer");
|
|
exit(1);
|
|
}
|
|
|
|
#ifndef USE_LIBBEGEMOT
|
|
due = evAddTime(evNowTime(),
|
|
evConsTime(ticks / 100, (ticks % 100) * 10000));
|
|
#endif
|
|
|
|
tp->udata = udata;
|
|
tp->owner = mod;
|
|
tp->func = func;
|
|
|
|
LIST_INSERT_HEAD(&timer_list, tp, link);
|
|
|
|
#ifdef USE_LIBBEGEMOT
|
|
if ((tp->id = poll_start_timer(ticks * 10, 0, tfunc, tp)) < 0) {
|
|
syslog(LOG_ERR, "cannot set timer: %m");
|
|
exit(1);
|
|
}
|
|
#else
|
|
if (evSetTimer(evctx, tfunc, tp, due, evConsTime(0, 0), &tp->id)
|
|
== -1) {
|
|
syslog(LOG_ERR, "cannot set timer: %m");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
return (tp);
|
|
}
|
|
|
|
/*
|
|
* Start a repeatable timer. When used with USE_LIBBEGEMOT the first argument
|
|
* is currently ignored and the initial number of ticks is set to the
|
|
* repeat number of ticks.
|
|
*/
|
|
void *
|
|
timer_start_repeat(u_int ticks __unused, u_int repeat_ticks,
|
|
void (*func)(void *), void *udata, struct lmodule *mod)
|
|
{
|
|
struct timer *tp;
|
|
#ifndef USE_LIBBEGEMOT
|
|
struct timespec due;
|
|
struct timespec inter;
|
|
#endif
|
|
|
|
if ((tp = malloc(sizeof(struct timer))) == NULL) {
|
|
syslog(LOG_CRIT, "out of memory for timer");
|
|
exit(1);
|
|
}
|
|
|
|
#ifndef USE_LIBBEGEMOT
|
|
due = evAddTime(evNowTime(),
|
|
evConsTime(ticks / 100, (ticks % 100) * 10000));
|
|
inter = evConsTime(repeat_ticks / 100, (repeat_ticks % 100) * 10000);
|
|
#endif
|
|
|
|
tp->udata = udata;
|
|
tp->owner = mod;
|
|
tp->func = func;
|
|
|
|
LIST_INSERT_HEAD(&timer_list, tp, link);
|
|
|
|
#ifdef USE_LIBBEGEMOT
|
|
if ((tp->id = poll_start_timer(repeat_ticks * 10, 1, trfunc, tp)) < 0) {
|
|
syslog(LOG_ERR, "cannot set timer: %m");
|
|
exit(1);
|
|
}
|
|
#else
|
|
if (evSetTimer(evctx, trfunc, tp, due, inter, &tp->id) == -1) {
|
|
syslog(LOG_ERR, "cannot set timer: %m");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
return (tp);
|
|
}
|
|
|
|
/*
|
|
* Stop a timer.
|
|
*/
|
|
void
|
|
timer_stop(void *p)
|
|
{
|
|
struct timer *tp = p;
|
|
|
|
LIST_REMOVE(tp, link);
|
|
#ifdef USE_LIBBEGEMOT
|
|
poll_stop_timer(tp->id);
|
|
#else
|
|
if (evClearTimer(evctx, tp->id) == -1) {
|
|
syslog(LOG_ERR, "cannot stop timer: %m");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
free(p);
|
|
}
|
|
|
|
static void
|
|
timer_flush(struct lmodule *mod)
|
|
{
|
|
struct timer *t, *t1;
|
|
|
|
t = LIST_FIRST(&timer_list);
|
|
while (t != NULL) {
|
|
t1 = LIST_NEXT(t, link);
|
|
if (t->owner == mod)
|
|
timer_stop(t);
|
|
t = t1;
|
|
}
|
|
}
|
|
|
|
static void
|
|
snmp_printf_func(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
static char *pend = NULL;
|
|
char *ret, *new;
|
|
|
|
va_start(ap, fmt);
|
|
vasprintf(&ret, fmt, ap);
|
|
va_end(ap);
|
|
|
|
if (ret == NULL)
|
|
return;
|
|
if (pend != NULL) {
|
|
if ((new = realloc(pend, strlen(pend) + strlen(ret) + 1))
|
|
== NULL) {
|
|
free(ret);
|
|
return;
|
|
}
|
|
pend = new;
|
|
strcat(pend, ret);
|
|
free(ret);
|
|
} else
|
|
pend = ret;
|
|
|
|
while ((ret = strchr(pend, '\n')) != NULL) {
|
|
*ret = '\0';
|
|
syslog(LOG_DEBUG, "%s", pend);
|
|
if (strlen(ret + 1) == 0) {
|
|
free(pend);
|
|
pend = NULL;
|
|
break;
|
|
}
|
|
strcpy(pend, ret + 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
snmp_error_func(const char *err, ...)
|
|
{
|
|
char errbuf[1000];
|
|
va_list ap;
|
|
|
|
if (!(snmp_trace & LOG_SNMP_ERRORS))
|
|
return;
|
|
|
|
va_start(ap, err);
|
|
snprintf(errbuf, sizeof(errbuf), "SNMP: ");
|
|
vsnprintf(errbuf + strlen(errbuf),
|
|
sizeof(errbuf) - strlen(errbuf), err, ap);
|
|
va_end(ap);
|
|
|
|
syslog(LOG_ERR, "%s", errbuf);
|
|
}
|
|
|
|
static void
|
|
snmp_debug_func(const char *err, ...)
|
|
{
|
|
char errbuf[1000];
|
|
va_list ap;
|
|
|
|
va_start(ap, err);
|
|
snprintf(errbuf, sizeof(errbuf), "SNMP: ");
|
|
vsnprintf(errbuf+strlen(errbuf), sizeof(errbuf)-strlen(errbuf),
|
|
err, ap);
|
|
va_end(ap);
|
|
|
|
syslog(LOG_DEBUG, "%s", errbuf);
|
|
}
|
|
|
|
static void
|
|
asn_error_func(const struct asn_buf *b, const char *err, ...)
|
|
{
|
|
char errbuf[1000];
|
|
va_list ap;
|
|
u_int i;
|
|
|
|
if (!(snmp_trace & LOG_ASN1_ERRORS))
|
|
return;
|
|
|
|
va_start(ap, err);
|
|
snprintf(errbuf, sizeof(errbuf), "ASN.1: ");
|
|
vsnprintf(errbuf + strlen(errbuf),
|
|
sizeof(errbuf) - strlen(errbuf), err, ap);
|
|
va_end(ap);
|
|
|
|
if (b != NULL) {
|
|
snprintf(errbuf + strlen(errbuf),
|
|
sizeof(errbuf) - strlen(errbuf), " at");
|
|
for (i = 0; b->asn_len > i; i++)
|
|
snprintf(errbuf + strlen(errbuf),
|
|
sizeof(errbuf) - strlen(errbuf),
|
|
" %02x", b->asn_cptr[i]);
|
|
}
|
|
|
|
syslog(LOG_ERR, "%s", errbuf);
|
|
}
|
|
|
|
/*
|
|
* Create a new community
|
|
*/
|
|
u_int
|
|
comm_define(u_int priv, const char *descr, struct lmodule *owner,
|
|
const char *str)
|
|
{
|
|
struct community *c, *p;
|
|
u_int ncomm;
|
|
|
|
/* generate an identifier */
|
|
do {
|
|
if ((ncomm = next_community_index++) == UINT_MAX)
|
|
next_community_index = 1;
|
|
TAILQ_FOREACH(c, &community_list, link)
|
|
if (c->value == ncomm)
|
|
break;
|
|
} while (c != NULL);
|
|
|
|
if ((c = malloc(sizeof(struct community))) == NULL) {
|
|
syslog(LOG_ERR, "comm_define: %m");
|
|
return (0);
|
|
}
|
|
c->owner = owner;
|
|
c->value = ncomm;
|
|
c->descr = descr;
|
|
c->string = NULL;
|
|
c->private = priv;
|
|
|
|
if (str != NULL) {
|
|
if((c->string = malloc(strlen(str)+1)) == NULL) {
|
|
free(c);
|
|
return (0);
|
|
}
|
|
strcpy(c->string, str);
|
|
}
|
|
|
|
/* make index */
|
|
if (c->owner == NULL) {
|
|
c->index.len = 1;
|
|
c->index.subs[0] = 0;
|
|
} else {
|
|
c->index = c->owner->index;
|
|
}
|
|
c->index.subs[c->index.len++] = c->private;
|
|
|
|
/*
|
|
* Insert ordered
|
|
*/
|
|
TAILQ_FOREACH(p, &community_list, link) {
|
|
if (asn_compare_oid(&p->index, &c->index) > 0) {
|
|
TAILQ_INSERT_BEFORE(p, c, link);
|
|
break;
|
|
}
|
|
}
|
|
if (p == NULL)
|
|
TAILQ_INSERT_TAIL(&community_list, c, link);
|
|
return (c->value);
|
|
}
|
|
|
|
const char *
|
|
comm_string(u_int ncomm)
|
|
{
|
|
struct community *p;
|
|
|
|
TAILQ_FOREACH(p, &community_list, link)
|
|
if (p->value == ncomm)
|
|
return (p->string);
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Delete all communities allocated by a module
|
|
*/
|
|
static void
|
|
comm_flush(struct lmodule *mod)
|
|
{
|
|
struct community *p, *p1;
|
|
|
|
p = TAILQ_FIRST(&community_list);
|
|
while (p != NULL) {
|
|
p1 = TAILQ_NEXT(p, link);
|
|
if (p->owner == mod) {
|
|
free(p->string);
|
|
TAILQ_REMOVE(&community_list, p, link);
|
|
free(p);
|
|
}
|
|
p = p1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Request ID handling.
|
|
*
|
|
* Allocate a new range of request ids. Use a first fit algorithm.
|
|
*/
|
|
u_int
|
|
reqid_allocate(int size, struct lmodule *mod)
|
|
{
|
|
u_int type;
|
|
struct idrange *r, *r1;
|
|
|
|
if (size <= 0 || size > INT32_MAX) {
|
|
syslog(LOG_CRIT, "%s: size out of range: %d", __func__, size);
|
|
return (0);
|
|
}
|
|
/* allocate a type id */
|
|
do {
|
|
if ((type = next_idrange++) == UINT_MAX)
|
|
next_idrange = 1;
|
|
TAILQ_FOREACH(r, &idrange_list, link)
|
|
if (r->type == type)
|
|
break;
|
|
} while(r != NULL);
|
|
|
|
/* find a range */
|
|
if (TAILQ_EMPTY(&idrange_list))
|
|
r = NULL;
|
|
else {
|
|
r = TAILQ_FIRST(&idrange_list);
|
|
if (r->base < size) {
|
|
while((r1 = TAILQ_NEXT(r, link)) != NULL) {
|
|
if (r1->base - (r->base + r->size) >= size)
|
|
break;
|
|
r = r1;
|
|
}
|
|
r = r1;
|
|
}
|
|
if (r == NULL) {
|
|
r1 = TAILQ_LAST(&idrange_list, idrange_list);
|
|
if (INT32_MAX - size + 1 < r1->base + r1->size) {
|
|
syslog(LOG_ERR, "out of id ranges (%u)", size);
|
|
return (0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* allocate structure */
|
|
if ((r1 = malloc(sizeof(struct idrange))) == NULL) {
|
|
syslog(LOG_ERR, "%s: %m", __FUNCTION__);
|
|
return (0);
|
|
}
|
|
|
|
r1->type = type;
|
|
r1->size = size;
|
|
r1->owner = mod;
|
|
if (TAILQ_EMPTY(&idrange_list) || r == TAILQ_FIRST(&idrange_list)) {
|
|
r1->base = 0;
|
|
TAILQ_INSERT_HEAD(&idrange_list, r1, link);
|
|
} else if (r == NULL) {
|
|
r = TAILQ_LAST(&idrange_list, idrange_list);
|
|
r1->base = r->base + r->size;
|
|
TAILQ_INSERT_TAIL(&idrange_list, r1, link);
|
|
} else {
|
|
r = TAILQ_PREV(r, idrange_list, link);
|
|
r1->base = r->base + r->size;
|
|
TAILQ_INSERT_AFTER(&idrange_list, r, r1, link);
|
|
}
|
|
r1->next = r1->base;
|
|
|
|
return (type);
|
|
}
|
|
|
|
int32_t
|
|
reqid_next(u_int type)
|
|
{
|
|
struct idrange *r;
|
|
int32_t id;
|
|
|
|
TAILQ_FOREACH(r, &idrange_list, link)
|
|
if (r->type == type)
|
|
break;
|
|
if (r == NULL) {
|
|
syslog(LOG_CRIT, "wrong idrange type");
|
|
abort();
|
|
}
|
|
if ((id = r->next++) == r->base + (r->size - 1))
|
|
r->next = r->base;
|
|
return (id);
|
|
}
|
|
|
|
int32_t
|
|
reqid_base(u_int type)
|
|
{
|
|
struct idrange *r;
|
|
|
|
TAILQ_FOREACH(r, &idrange_list, link)
|
|
if (r->type == type)
|
|
return (r->base);
|
|
syslog(LOG_CRIT, "wrong idrange type");
|
|
abort();
|
|
}
|
|
|
|
u_int
|
|
reqid_type(int32_t reqid)
|
|
{
|
|
struct idrange *r;
|
|
|
|
TAILQ_FOREACH(r, &idrange_list, link)
|
|
if (reqid >= r->base && reqid <= r->base + (r->size - 1))
|
|
return (r->type);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
reqid_istype(int32_t reqid, u_int type)
|
|
{
|
|
return (reqid_type(reqid) == type);
|
|
}
|
|
|
|
/*
|
|
* Delete all communities allocated by a module
|
|
*/
|
|
static void
|
|
reqid_flush(struct lmodule *mod)
|
|
{
|
|
struct idrange *p, *p1;
|
|
|
|
p = TAILQ_FIRST(&idrange_list);
|
|
while (p != NULL) {
|
|
p1 = TAILQ_NEXT(p, link);
|
|
if (p->owner == mod) {
|
|
TAILQ_REMOVE(&idrange_list, p, link);
|
|
free(p);
|
|
}
|
|
p = p1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Merge the given tree for the given module into the main tree.
|
|
*/
|
|
static int
|
|
compare_node(const void *v1, const void *v2)
|
|
{
|
|
const struct snmp_node *n1 = v1;
|
|
const struct snmp_node *n2 = v2;
|
|
|
|
return (asn_compare_oid(&n1->oid, &n2->oid));
|
|
}
|
|
static int
|
|
tree_merge(const struct snmp_node *ntree, u_int nsize, struct lmodule *mod)
|
|
{
|
|
struct snmp_node *xtree;
|
|
u_int i;
|
|
|
|
xtree = realloc(tree, sizeof(*tree) * (tree_size + nsize));
|
|
if (xtree == NULL) {
|
|
syslog(LOG_ERR, "tree_merge: %m");
|
|
return (-1);
|
|
}
|
|
tree = xtree;
|
|
memcpy(&tree[tree_size], ntree, sizeof(*tree) * nsize);
|
|
|
|
for (i = 0; i < nsize; i++)
|
|
tree[tree_size + i].tree_data = mod;
|
|
|
|
tree_size += nsize;
|
|
|
|
qsort(tree, tree_size, sizeof(tree[0]), compare_node);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Remove all nodes belonging to the loadable module
|
|
*/
|
|
static void
|
|
tree_unmerge(struct lmodule *mod)
|
|
{
|
|
u_int s, d;
|
|
|
|
for(s = d = 0; s < tree_size; s++)
|
|
if (tree[s].tree_data != mod) {
|
|
if (s != d)
|
|
tree[d] = tree[s];
|
|
d++;
|
|
}
|
|
tree_size = d;
|
|
}
|
|
|
|
/*
|
|
* Loadable modules
|
|
*/
|
|
struct lmodule *
|
|
lm_load(const char *path, const char *section)
|
|
{
|
|
struct lmodule *m;
|
|
int err;
|
|
int i;
|
|
char *av[MAX_MOD_ARGS + 1];
|
|
int ac;
|
|
u_int u;
|
|
|
|
if ((m = malloc(sizeof(*m))) == NULL) {
|
|
syslog(LOG_ERR, "lm_load: %m");
|
|
return (NULL);
|
|
}
|
|
m->handle = NULL;
|
|
m->flags = 0;
|
|
strcpy(m->section, section);
|
|
|
|
if ((m->path = malloc(strlen(path) + 1)) == NULL) {
|
|
syslog(LOG_ERR, "lm_load: %m");
|
|
goto err;
|
|
}
|
|
strcpy(m->path, path);
|
|
|
|
/*
|
|
* Make index
|
|
*/
|
|
m->index.subs[0] = strlen(section);
|
|
m->index.len = m->index.subs[0] + 1;
|
|
for (u = 0; u < m->index.subs[0]; u++)
|
|
m->index.subs[u + 1] = section[u];
|
|
|
|
/*
|
|
* Load the object file and locate the config structure
|
|
*/
|
|
if ((m->handle = dlopen(m->path, RTLD_NOW|RTLD_GLOBAL)) == NULL) {
|
|
syslog(LOG_ERR, "lm_load: open %s", dlerror());
|
|
goto err;
|
|
}
|
|
|
|
if ((m->config = dlsym(m->handle, "config")) == NULL) {
|
|
syslog(LOG_ERR, "lm_load: no 'config' symbol %s", dlerror());
|
|
goto err;
|
|
}
|
|
|
|
/*
|
|
* Insert it into the right place
|
|
*/
|
|
INSERT_OBJECT_OID(m, &lmodules);
|
|
|
|
/* preserve order */
|
|
if (community == COMM_INITIALIZE) {
|
|
m->flags |= LM_ONSTARTLIST;
|
|
TAILQ_INSERT_TAIL(&modules_start, m, start);
|
|
}
|
|
|
|
/*
|
|
* make the argument vector.
|
|
*/
|
|
ac = 0;
|
|
for (i = 0; i < nprogargs; i++) {
|
|
if (strlen(progargs[i]) >= strlen(section) + 1 &&
|
|
strncmp(progargs[i], section, strlen(section)) == 0 &&
|
|
progargs[i][strlen(section)] == ':') {
|
|
if (ac == MAX_MOD_ARGS) {
|
|
syslog(LOG_WARNING, "too many arguments for "
|
|
"module '%s", section);
|
|
break;
|
|
}
|
|
av[ac++] = &progargs[i][strlen(section)+1];
|
|
}
|
|
}
|
|
av[ac] = NULL;
|
|
|
|
/*
|
|
* Run the initialization function
|
|
*/
|
|
if ((err = (*m->config->init)(m, ac, av)) != 0) {
|
|
syslog(LOG_ERR, "lm_load: init failed: %d", err);
|
|
TAILQ_REMOVE(&lmodules, m, link);
|
|
goto err;
|
|
}
|
|
|
|
return (m);
|
|
|
|
err:
|
|
if (m->handle)
|
|
dlclose(m->handle);
|
|
free(m->path);
|
|
free(m);
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Start a module
|
|
*/
|
|
void
|
|
lm_start(struct lmodule *mod)
|
|
{
|
|
const struct lmodule *m;
|
|
|
|
/*
|
|
* Merge tree. If this fails, unload the module.
|
|
*/
|
|
if (tree_merge(mod->config->tree, mod->config->tree_size, mod)) {
|
|
lm_unload(mod);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Read configuration
|
|
*/
|
|
if (read_config(config_file, mod)) {
|
|
syslog(LOG_ERR, "error in config file");
|
|
lm_unload(mod);
|
|
return;
|
|
}
|
|
if (mod->config->start)
|
|
(*mod->config->start)();
|
|
|
|
mod->flags |= LM_STARTED;
|
|
|
|
/*
|
|
* Inform other modules
|
|
*/
|
|
TAILQ_FOREACH(m, &lmodules, link)
|
|
if (m->config->loading)
|
|
(*m->config->loading)(mod, 1);
|
|
}
|
|
|
|
|
|
/*
|
|
* Unload a module.
|
|
*/
|
|
void
|
|
lm_unload(struct lmodule *m)
|
|
{
|
|
int err;
|
|
const struct lmodule *mod;
|
|
|
|
TAILQ_REMOVE(&lmodules, m, link);
|
|
if (m->flags & LM_ONSTARTLIST)
|
|
TAILQ_REMOVE(&modules_start, m, start);
|
|
tree_unmerge(m);
|
|
|
|
if ((m->flags & LM_STARTED) && m->config->fini &&
|
|
(err = (*m->config->fini)()) != 0)
|
|
syslog(LOG_WARNING, "lm_unload(%s): fini %d", m->section, err);
|
|
|
|
comm_flush(m);
|
|
reqid_flush(m);
|
|
timer_flush(m);
|
|
fd_flush(m);
|
|
|
|
dlclose(m->handle);
|
|
free(m->path);
|
|
|
|
/*
|
|
* Inform other modules
|
|
*/
|
|
TAILQ_FOREACH(mod, &lmodules, link)
|
|
if (mod->config->loading)
|
|
(*mod->config->loading)(m, 0);
|
|
|
|
free(m);
|
|
}
|
|
|
|
/*
|
|
* Register an object resource and return the index (or 0 on failures)
|
|
*/
|
|
u_int
|
|
or_register(const struct asn_oid *or, const char *descr, struct lmodule *mod)
|
|
{
|
|
struct objres *objres, *or1;
|
|
u_int idx;
|
|
|
|
/* find a free index */
|
|
idx = 1;
|
|
for (objres = TAILQ_FIRST(&objres_list);
|
|
objres != NULL;
|
|
objres = TAILQ_NEXT(objres, link)) {
|
|
if ((or1 = TAILQ_NEXT(objres, link)) == NULL ||
|
|
or1->index > objres->index + 1) {
|
|
idx = objres->index + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((objres = malloc(sizeof(*objres))) == NULL)
|
|
return (0);
|
|
|
|
objres->index = idx;
|
|
objres->oid = *or;
|
|
strlcpy(objres->descr, descr, sizeof(objres->descr));
|
|
objres->uptime = (uint32_t)(get_ticks() - start_tick);
|
|
objres->module = mod;
|
|
|
|
INSERT_OBJECT_INT(objres, &objres_list);
|
|
|
|
systemg.or_last_change = objres->uptime;
|
|
|
|
return (idx);
|
|
}
|
|
|
|
void
|
|
or_unregister(u_int idx)
|
|
{
|
|
struct objres *objres;
|
|
|
|
TAILQ_FOREACH(objres, &objres_list, link)
|
|
if (objres->index == idx) {
|
|
TAILQ_REMOVE(&objres_list, objres, link);
|
|
free(objres);
|
|
return;
|
|
}
|
|
}
|