blob: 16dff50e7d9a1d1ece4fecd0e863317363355dfb [file] [log] [blame]
/*
* snmptrapd.c - receive and log snmp traps
*
*/
/*****************************************************************
Copyright 1989, 1991, 1992 by Carnegie Mellon University
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of CMU not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
******************************************************************/
#include <net-snmp/net-snmp-config.h>
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#include <sys/types.h>
#if HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_SYS_SOCKIO_H
#include <sys/sockio.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include <stdio.h>
#if !defined(mingw32) && defined(HAVE_SYS_TIME_H)
# include <sys/time.h>
# if TIME_WITH_SYS_TIME
# include <time.h>
# endif
#else
# include <time.h>
#endif
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#if HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#if HAVE_SYSLOG_H
#include <syslog.h>
#endif
#if HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#if HAVE_NET_IF_H
#include <net/if.h>
#endif
#if HAVE_NETDB_H
#include <netdb.h>
#endif
#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
#if HAVE_PROCESS_H /* Win32-getpid */
#include <process.h>
#endif
#if HAVE_PWD_H
#include <pwd.h>
#endif
#if HAVE_GRP_H
#include <grp.h>
#endif
#include <signal.h>
#include <errno.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/library/fd_event_manager.h>
#include "snmptrapd_handlers.h"
#include "snmptrapd_log.h"
#include "snmptrapd_auth.h"
#include "notification-log-mib/notification_log.h"
#include "tlstm-mib/snmpTlstmCertToTSNTable/snmpTlstmCertToTSNTable.h"
#include "mibII/vacm_conf.h"
#ifdef NETSNMP_EMBEDDED_PERL
#include "snmp_perl.h"
#endif
/*
* Include winservice.h to support Windows Service
*/
#ifdef WIN32
#include <windows.h>
#include <tchar.h>
#include <net-snmp/library/winservice.h>
#define WIN32SERVICE
#endif
#if NETSNMP_USE_LIBWRAP
#include <tcpd.h>
#endif
#ifndef BSD4_3
#define BSD4_2
#endif
#ifndef FD_SET
typedef long fd_mask;
#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */
#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
#define FD_ZERO(p) memset((p), 0, sizeof(*(p)))
#endif
char *logfile = NULL;
extern int SyslogTrap;
extern int dropauth;
static int reconfig = 0;
char ddefault_port[] = "udp:162"; /* Default default port */
char *default_port = ddefault_port;
#if HAVE_GETPID
FILE *PID;
char *pid_file = NULL;
#endif
extern void parse_format(const char *token, char *line);
char *trap1_fmt_str_remember = NULL;
int dofork = 1;
extern int netsnmp_running;
#ifdef NETSNMP_USE_MYSQL
extern int netsnmp_mysql_init(void);
extern void snmptrapd_register_sql_configs( void );
#endif
/*
* These definitions handle 4.2 systems without additional syslog facilities.
*/
#ifndef LOG_CONS
#define LOG_CONS 0 /* Don't bother if not defined... */
#endif
#ifndef LOG_PID
#define LOG_PID 0 /* Don't bother if not defined... */
#endif
#ifndef LOG_LOCAL0
#define LOG_LOCAL0 0
#endif
#ifndef LOG_LOCAL1
#define LOG_LOCAL1 0
#endif
#ifndef LOG_LOCAL2
#define LOG_LOCAL2 0
#endif
#ifndef LOG_LOCAL3
#define LOG_LOCAL3 0
#endif
#ifndef LOG_LOCAL4
#define LOG_LOCAL4 0
#endif
#ifndef LOG_LOCAL5
#define LOG_LOCAL5 0
#endif
#ifndef LOG_LOCAL6
#define LOG_LOCAL6 0
#endif
#ifndef LOG_LOCAL7
#define LOG_LOCAL7 0
#endif
#ifndef LOG_DAEMON
#define LOG_DAEMON 0
#endif
/*
* Include an extra Facility variable to allow command line adjustment of
* syslog destination
*/
int Facility = LOG_DAEMON;
#ifdef WIN32SERVICE
/*
* SNMP Trap Receiver Status
*/
#define SNMPTRAPD_RUNNING 1
#define SNMPTRAPD_STOPPED 0
int trapd_status = SNMPTRAPD_STOPPED;
/* app_name_long used for SCM, registry etc */
LPCTSTR app_name_long = _T("Net-SNMP Trap Handler"); /* Application Name */
#endif
const char *app_name = "snmptrapd";
struct timeval Now;
void trapd_update_config(void);
#ifdef WIN32SERVICE
void StopSnmpTrapd(void);
int SnmpTrapdMain(int argc, TCHAR * argv[]);
int __cdecl _tmain(int argc, TCHAR * argv[]);
#else
int main(int, char **);
#endif
#if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
extern void subagent_init(void);
#endif
void
usage(void)
{
#ifdef WIN32SERVICE
fprintf(stderr, "\nUsage: snmptrapd [-register] [-quiet] [OPTIONS] [LISTENING ADDRESSES]");
fprintf(stderr, "\n snmptrapd [-unregister] [-quiet]");
#else
fprintf(stderr, "Usage: snmptrapd [OPTIONS] [LISTENING ADDRESSES]\n");
#endif
fprintf(stderr, "\n\tNET-SNMP Version: %s\n", netsnmp_get_version());
fprintf(stderr, "\tWeb: http://www.net-snmp.org/\n");
fprintf(stderr, "\tEmail: net-snmp-coders@lists.sourceforge.net\n");
fprintf(stderr, "\n");
fprintf(stderr, " -a\t\t\tignore authentication failure traps\n");
fprintf(stderr, " -A\t\t\tappend to log file rather than truncating it\n");
fprintf(stderr, " -c FILE\t\tread FILE as a configuration file\n");
fprintf(stderr,
" -C\t\t\tdo not read the default configuration files\n");
fprintf(stderr, " -d\t\t\tdump sent and received SNMP packets\n");
fprintf(stderr, " -D[TOKEN[,...]]\t\tturn on debugging output for the specified TOKENs\n\t\t\t (ALL gives extremely verbose debugging output)\n");
fprintf(stderr, " -f\t\t\tdo not fork from the shell\n");
fprintf(stderr,
" -F FORMAT\t\tuse specified format for logging to standard error\n");
#if HAVE_UNISTD_H
fprintf(stderr, " -g GID\t\tchange to this numeric gid after opening\n"
"\t\t\t transport endpoints\n");
#endif
fprintf(stderr, " -h, --help\t\tdisplay this usage message\n");
fprintf(stderr,
" -H\t\t\tdisplay configuration file directives understood\n");
fprintf(stderr,
" -m MIBLIST\t\tuse MIBLIST instead of the default MIB list\n");
fprintf(stderr,
" -M DIRLIST\t\tuse DIRLIST as the list of locations\n\t\t\t to look for MIBs\n");
fprintf(stderr,
" -n\t\t\tuse numeric addresses instead of attempting\n\t\t\t hostname lookups (no DNS)\n");
#if HAVE_GETPID
fprintf(stderr, " -p FILE\t\tstore process id in FILE\n");
#endif
#ifdef WIN32SERVICE
fprintf(stderr, " -register\t\tregister as a Windows service\n");
fprintf(stderr, " \t\t\t (followed by -quiet to prevent message popups)\n");
fprintf(stderr, " \t\t\t (followed by the startup parameter list)\n");
fprintf(stderr, " \t\t\t Note that some parameters are not relevant when running as a service\n");
#endif
fprintf(stderr, " -t\t\t\tPrevent traps from being logged to syslog\n");
#if HAVE_UNISTD_H
fprintf(stderr, " -u UID\t\tchange to this uid (numeric or textual) after\n"
"\t\t\t opening transport endpoints\n");
#endif
#ifdef WIN32SERVICE
fprintf(stderr, " -unregister\t\tunregister as a Windows service\n");
fprintf(stderr, " \t\t\t (followed -quiet to prevent message popups)\n");
#endif
fprintf(stderr, " -v, --version\t\tdisplay version information\n");
#if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
fprintf(stderr, " -x ADDRESS\t\tuse ADDRESS as AgentX address\n");
#endif
fprintf(stderr,
" -O <OUTOPTS>\t\ttoggle options controlling output display\n");
snmp_out_toggle_options_usage("\t\t\t", stderr);
fprintf(stderr,
" -L <LOGOPTS>\t\ttoggle options controlling where to log to\n");
snmp_log_options_usage("\t\t\t", stderr);
}
static void
version(void)
{
printf("\nNET-SNMP Version: %s\n", netsnmp_get_version());
printf("Web: http://www.net-snmp.org/\n");
printf("Email: net-snmp-coders@lists.sourceforge.net\n\n");
exit(0);
}
RETSIGTYPE
term_handler(int sig)
{
#ifdef WIN32SERVICE
extern netsnmp_session *main_session;
#endif
netsnmp_running = 0;
#ifdef WIN32SERVICE
/*
* In case of windows, select() in receive() function will not return
* on signal. Thats why following function is called, which closes the
* socket descriptors and causes the select() to return
*/
snmp_close(main_session);
#endif
}
#ifdef SIGHUP
RETSIGTYPE
hup_handler(int sig)
{
reconfig = 1;
signal(SIGHUP, hup_handler);
}
#endif
static int
pre_parse(netsnmp_session * session, netsnmp_transport *transport,
void *transport_data, int transport_data_length)
{
#if NETSNMP_USE_LIBWRAP
char *addr_string = NULL;
if (transport != NULL && transport->f_fmtaddr != NULL) {
/*
* Okay I do know how to format this address for logging.
*/
addr_string = transport->f_fmtaddr(transport, transport_data,
transport_data_length);
/*
* Don't forget to free() it.
*/
}
if (addr_string != NULL) {
/* Catch udp,udp6,tcp,tcp6 transports using "[" */
char *tcpudpaddr = strstr(addr_string, "[");
if ( tcpudpaddr != 0 ) {
char sbuf[64];
char *xp;
strlcpy(sbuf, tcpudpaddr + 1, sizeof(sbuf));
xp = strstr(sbuf, "]");
if (xp)
*xp = '\0';
if (hosts_ctl("snmptrapd", STRING_UNKNOWN,
sbuf, STRING_UNKNOWN) == 0) {
DEBUGMSGTL(("snmptrapd:libwrap", "%s rejected", addr_string));
SNMP_FREE(addr_string);
return 0;
}
}
SNMP_FREE(addr_string);
} else {
if (hosts_ctl("snmptrapd", STRING_UNKNOWN,
STRING_UNKNOWN, STRING_UNKNOWN) == 0) {
DEBUGMSGTL(("snmptrapd:libwrap", "[unknown] rejected"));
return 0;
}
}
#endif/* NETSNMP_USE_LIBWRAP */
return 1;
}
static netsnmp_session *
snmptrapd_add_session(netsnmp_transport *t)
{
netsnmp_session sess, *session = &sess, *rc = NULL;
snmp_sess_init(session);
session->peername = SNMP_DEFAULT_PEERNAME; /* Original code had NULL here */
session->version = SNMP_DEFAULT_VERSION;
session->community_len = SNMP_DEFAULT_COMMUNITY_LEN;
session->retries = SNMP_DEFAULT_RETRIES;
session->timeout = SNMP_DEFAULT_TIMEOUT;
session->callback = snmp_input;
session->callback_magic = (void *) t;
session->authenticator = NULL;
sess.isAuthoritative = SNMP_SESS_UNKNOWNAUTH;
rc = snmp_add(session, t, pre_parse, NULL);
if (rc == NULL) {
snmp_sess_perror("snmptrapd", session);
}
return rc;
}
static void
snmptrapd_close_sessions(netsnmp_session * sess_list)
{
netsnmp_session *s = NULL, *next = NULL;
for (s = sess_list; s != NULL; s = next) {
next = s->next;
snmp_close(s);
}
}
void
parse_trapd_address(const char *token, char *cptr)
{
char buf[BUFSIZ];
char *p;
cptr = copy_nword(cptr, buf, sizeof(buf));
if (default_port == ddefault_port) {
default_port = strdup(buf);
} else {
p = malloc(strlen(buf) + 1 + strlen(default_port) + 1);
if (p) {
strcat(p, buf);
strcat(p, ",");
strcat(p, default_port );
}
free(default_port);
default_port = p;
}
}
void
free_trapd_address(void)
{
if (default_port != ddefault_port) {
free(default_port);
}
}
void
parse_config_doNotLogTraps(const char *token, char *cptr)
{
if (atoi(cptr) > 0)
SyslogTrap++;
}
void
free_config_pidFile(void)
{
if (pid_file)
free(pid_file);
pid_file = NULL;
}
void
parse_config_pidFile(const char *token, char *cptr)
{
free_config_pidFile();
pid_file = strdup (cptr);
}
#ifdef HAVE_UNISTD_H
void
parse_config_agentuser(const char *token, char *cptr)
{
#if defined(HAVE_GETPWNAM) && defined(HAVE_PWD_H)
struct passwd *info;
#endif
if (cptr[0] == '#') {
char *ecp;
int uid;
uid = strtoul(cptr + 1, &ecp, 10);
if (*ecp != 0) {
config_perror("Bad number");
} else {
netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_USERID, uid);
}
}
#if defined(HAVE_GETPWNAM) && defined(HAVE_PWD_H)
else if ((info = getpwnam(cptr)) != NULL) {
netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_USERID, info->pw_uid);
} else {
config_perror("User not found in passwd database");
}
endpwent();
#endif
}
void
parse_config_agentgroup(const char *token, char *cptr)
{
#if defined(HAVE_GETGRNAM) && defined(HAVE_GRP_H)
struct group *info;
#endif
if (cptr[0] == '#') {
char *ecp;
int gid = strtoul(cptr + 1, &ecp, 10);
if (*ecp != 0) {
config_perror("Bad number");
} else {
netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_GROUPID, gid);
}
}
#if defined(HAVE_GETGRNAM) && defined(HAVE_GRP_H)
else if ((info = getgrnam(cptr)) != NULL) {
netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_GROUPID, info->gr_gid);
} else {
config_perror("Group not found in group database");
}
endpwent();
#endif
}
#endif
void
parse_config_doNotFork(const char *token, char *cptr)
{
if (netsnmp_ds_parse_boolean(cptr) == 1)
dofork = 0;
}
void
parse_config_ignoreAuthFailure(const char *token, char *cptr)
{
if (netsnmp_ds_parse_boolean(cptr) == 1)
dropauth = 1;
}
void
parse_config_outputOption(const char *token, char *cptr)
{
char *cp;
cp = snmp_out_toggle_options(cptr);
if (cp != NULL) {
fprintf(stderr, "Unknown output option passed to -O: %c\n",
*cp);
}
}
/*******************************************************************-o-******
* main - Non Windows
* SnmpTrapdMain - Windows to support windows service
*
* Parameters:
* argc
* *argv[]
*
* Returns:
* 0 Always succeeds. (?)
*
*
* Setup and start the trap receiver daemon.
*
* Also successfully EXITs with zero for some options.
*/
int
#ifdef WIN32SERVICE
SnmpTrapdMain(int argc, TCHAR * argv[])
#else
main(int argc, char *argv[])
#endif
{
char options[128] = "aAc:CdD::efF:g:hHI:L:m:M:no:O:PqsS:tu:vx:-:";
netsnmp_session *sess_list = NULL, *ss = NULL;
netsnmp_transport *transport = NULL;
int arg, i = 0;
int uid = 0, gid = 0;
int count, numfds, block;
fd_set readfds,writefds,exceptfds;
struct timeval timeout, *tvp;
char *cp, *listen_ports = NULL;
#if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
int agentx_subagent = 1;
#endif
netsnmp_trapd_handler *traph;
#ifndef WIN32
/*
* close all non-standard file descriptors we may have
* inherited from the shell.
*/
for (i = getdtablesize() - 1; i > 2; --i) {
(void) close(i);
}
#endif /* #WIN32 */
#ifdef SIGTERM
signal(SIGTERM, term_handler);
#endif
#ifdef SIGHUP
signal(SIGHUP, SIG_IGN); /* do not terminate on early SIGHUP */
#endif
#ifdef SIGINT
signal(SIGINT, term_handler);
#endif
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN); /* 'Inline' failure of wayward readers */
#endif
/*
* register our configuration handlers now so -H properly displays them
*/
snmptrapd_register_configs( );
#ifdef NETSNMP_USE_MYSQL
snmptrapd_register_sql_configs( );
#endif
init_usm_conf( "snmptrapd" );
register_config_handler("snmptrapd", "snmpTrapdAddr",
parse_trapd_address, free_trapd_address, "string");
register_config_handler("snmptrapd", "doNotLogTraps",
parse_config_doNotLogTraps, NULL, "(1|yes|true|0|no|false)");
#if HAVE_GETPID
register_config_handler("snmptrapd", "pidFile",
parse_config_pidFile, NULL, "string");
#endif
#ifdef HAVE_UNISTD_H
register_config_handler("snmptrapd", "agentuser",
parse_config_agentuser, NULL, "userid");
register_config_handler("snmptrapd", "agentgroup",
parse_config_agentgroup, NULL, "groupid");
#endif
register_config_handler("snmptrapd", "doNotFork",
parse_config_doNotFork, NULL, "(1|yes|true|0|no|false)");
register_config_handler("snmptrapd", "ignoreAuthFailure",
parse_config_ignoreAuthFailure, NULL, "(1|yes|true|0|no|false)");
register_config_handler("snmptrapd", "outputOption",
parse_config_outputOption, NULL, "string");
/*
* Add some options if they are available.
*/
#if HAVE_GETPID
strcat(options, "p:");
#endif
#ifdef WIN32
snmp_log_syslogname(app_name_long);
#else
snmp_log_syslogname(app_name);
#endif
/*
* Now process options normally.
*/
while ((arg = getopt(argc, argv, options)) != EOF) {
switch (arg) {
case '-':
if (strcasecmp(optarg, "help") == 0) {
usage();
exit(0);
}
if (strcasecmp(optarg, "version") == 0) {
version();
exit(0);
}
handle_long_opt(optarg);
break;
case 'a':
dropauth = 1;
break;
case 'A':
netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_APPEND_LOGFILES, 1);
break;
case 'c':
if (optarg != NULL) {
netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_OPTIONALCONFIG, optarg);
} else {
usage();
exit(1);
}
break;
case 'C':
netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_DONT_READ_CONFIGS, 1);
break;
case 'd':
snmp_set_dump_packet(1);
break;
case 'D':
debug_register_tokens(optarg);
snmp_set_do_debugging(1);
break;
case 'f':
dofork = 0;
break;
case 'F':
if (optarg != NULL) {
if (( strncmp( optarg, "print", 5 ) == 0 ) ||
( strncmp( optarg, "syslog", 6 ) == 0 ) ||
( strncmp( optarg, "execute", 7 ) == 0 )) {
/* New style: "type=format" */
trap1_fmt_str_remember = strdup(optarg);
cp = strchr( trap1_fmt_str_remember, '=' );
if (cp)
*cp = ' ';
} else {
/* Old style: implicitly "print=format" */
trap1_fmt_str_remember = malloc(strlen(optarg) + 7);
sprintf( trap1_fmt_str_remember, "print %s", optarg );
}
} else {
usage();
exit(1);
}
break;
#if HAVE_UNISTD_H
case 'g':
if (optarg != NULL) {
netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_GROUPID, gid = atoi(optarg));
} else {
usage();
exit(1);
}
break;
#endif
case 'h':
usage();
exit(0);
case 'H':
init_agent("snmptrapd");
#ifdef USING_NOTIFICATION_LOG_MIB_NOTIFICATION_LOG_MODULE
init_notification_log();
#endif
#ifdef NETSNMP_EMBEDDED_PERL
init_perl();
#endif
init_snmp("snmptrapd");
fprintf(stderr, "Configuration directives understood:\n");
read_config_print_usage(" ");
exit(0);
case 'I':
if (optarg != NULL) {
add_to_init_list(optarg);
} else {
usage();
}
break;
case 'S':
fprintf(stderr,
"Warning: -S option has been withdrawn; use -Ls <facility> instead\n");
exit(1);
break;
case 'm':
if (optarg != NULL) {
setenv("MIBS", optarg, 1);
} else {
usage();
exit(1);
}
break;
case 'M':
if (optarg != NULL) {
setenv("MIBDIRS", optarg, 1);
} else {
usage();
exit(1);
}
break;
case 'n':
netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_APP_NUMERIC_IP, 1);
break;
case 'o':
fprintf(stderr,
"Warning: -o option has been withdrawn; use -Lf <file> instead\n");
exit(1);
break;
case 'O':
cp = snmp_out_toggle_options(optarg);
if (cp != NULL) {
fprintf(stderr, "Unknown output option passed to -O: %c\n",
*cp);
usage();
exit(1);
}
break;
case 'L':
if (snmp_log_options( optarg, argc, argv ) < 0 ) {
usage();
exit(1);
}
break;
#if HAVE_GETPID
case 'p':
if (optarg != NULL) {
parse_config_pidFile(NULL, optarg);
} else {
usage();
exit(1);
}
break;
#endif
case 'P':
fprintf(stderr,
"Warning: -P option has been withdrawn; use -f -Le instead\n");
exit(1);
break;
case 's':
fprintf(stderr,
"Warning: -s option has been withdrawn; use -Lsd instead\n");
exit(1);
break;
case 't':
SyslogTrap++;
break;
#if HAVE_UNISTD_H
case 'u':
if (optarg != NULL) {
char *ecp;
uid = strtoul(optarg, &ecp, 10);
if (*ecp) {
#if HAVE_GETPWNAM && HAVE_PWD_H
struct passwd *info;
info = getpwnam(optarg);
if (info) {
uid = info->pw_uid;
} else {
#endif
fprintf(stderr, "Bad user id: %s\n", optarg);
exit(1);
#if HAVE_GETPWNAM && HAVE_PWD_H
}
#endif
}
netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_USERID, uid);
} else {
usage();
exit(1);
}
break;
#endif
case 'v':
version();
exit(0);
break;
case 'x':
if (optarg != NULL) {
netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_X_SOCKET, optarg);
} else {
usage();
exit(1);
}
break;
default:
fprintf(stderr, "invalid option: -%c\n", arg);
usage();
exit(1);
break;
}
}
if (optind < argc) {
/*
* There are optional transport addresses on the command line.
*/
for (i = optind; i < argc; i++) {
char *astring;
if (listen_ports != NULL) {
astring = malloc(strlen(listen_ports) + 2 + strlen(argv[i]));
if (astring == NULL) {
fprintf(stderr, "malloc failure processing argv[%d]\n", i);
exit(1);
}
sprintf(astring, "%s,%s", listen_ports, argv[i]);
free(listen_ports);
listen_ports = astring;
} else {
listen_ports = strdup(argv[i]);
if (listen_ports == NULL) {
fprintf(stderr, "malloc failure processing argv[%d]\n", i);
exit(1);
}
}
}
}
SOCK_STARTUP;
/*
* I'm being lazy here, and not checking the
* return value from these registration calls.
* Don't try this at home, children!
*/
if (0 == snmp_get_do_logging()) {
traph = netsnmp_add_global_traphandler(NETSNMPTRAPD_PRE_HANDLER,
syslog_handler);
traph->authtypes = TRAP_AUTH_LOG;
snmp_enable_syslog();
} else {
traph = netsnmp_add_global_traphandler(NETSNMPTRAPD_PRE_HANDLER,
print_handler);
traph->authtypes = TRAP_AUTH_LOG;
}
#if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
/*
* we're an agentx subagent?
*/
if (agentx_subagent) {
/*
* make us a agentx client.
*/
netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_ROLE, 1);
}
#endif
/*
* don't fail if we can't do agentx (ie, socket not there, or not root)
*/
netsnmp_ds_toggle_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_NO_ROOT_ACCESS);
/*
* ignore any warning messages.
*/
netsnmp_ds_toggle_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_NO_CONNECTION_WARNINGS);
/*
* initialize the agent library
*/
init_agent("snmptrapd");
#if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
/*
* initialize local modules
*/
if (agentx_subagent) {
#ifdef USING_SNMPV3_SNMPENGINE_MODULE
extern void register_snmpEngine_scalars_context(const char *);
#endif
subagent_init();
#ifdef USING_NOTIFICATION_LOG_MIB_NOTIFICATION_LOG_MODULE
/* register the notification log table */
if (should_init("notificationLogMib")) {
netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_NOTIF_LOG_CTX,
"snmptrapd");
traph = netsnmp_add_global_traphandler(NETSNMPTRAPD_POST_HANDLER,
notification_handler);
traph->authtypes = TRAP_AUTH_LOG;
init_notification_log();
}
#endif
#ifdef USING_SNMPV3_SNMPENGINE_MODULE
/*
* register scalars from SNMP-FRAMEWORK-MIB::snmpEngineID group;
* allows engineID probes via the master agent under the
* snmptrapd context
*/
register_snmpEngine_scalars_context("snmptrapd");
#endif
}
#endif /* USING_AGENTX_SUBAGENT_MODULE && !NETSNMP_SNMPTRAPD_DISABLE_AGENTX */
/* register our authorization handler */
init_netsnmp_trapd_auth();
#if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
if (agentx_subagent) {
#ifdef USING_AGENT_NSVACMACCESSTABLE_MODULE
extern void init_register_nsVacm_context(const char *);
#endif
#ifdef USING_SNMPV3_USMUSER_MODULE
extern void init_register_usmUser_context(const char *);
/* register ourselves as having a USM user database */
init_register_usmUser_context("snmptrapd");
#endif
#ifdef USING_AGENT_NSVACMACCESSTABLE_MODULE
/* register net-snmp vacm extensions */
init_register_nsVacm_context("snmptrapd");
#endif
#ifdef USING_TLSTM_MIB_SNMPTLSTMCERTTOTSNTABLE_MODULE
init_snmpTlstmCertToTSNTable_context("snmptrapd");
#endif
}
#endif
#ifdef NETSNMP_EMBEDDED_PERL
init_perl();
{
/* set the default path to load */
char init_file[SNMP_MAXBUF];
snprintf(init_file, sizeof(init_file) - 1,
"%s/%s", SNMPSHAREPATH, "snmp_perl_trapd.pl");
netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_PERL_INIT_FILE,
init_file);
}
#endif
/*
* Initialize the world.
*/
init_snmp("snmptrapd");
#ifdef SIGHUP
signal(SIGHUP, hup_handler);
#endif
if (trap1_fmt_str_remember) {
parse_format( NULL, trap1_fmt_str_remember );
}
if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_QUIT_IMMEDIATELY)) {
/*
* just starting up to process specific configuration and then
* shutting down immediately.
*/
netsnmp_running = 0;
}
/*
* if no logging options on command line or in conf files, use syslog
*/
if (0 == snmp_get_do_logging()) {
#ifdef WIN32
snmp_enable_syslog_ident(app_name_long, Facility);
#else
snmp_enable_syslog_ident(app_name, Facility);
#endif
}
if (listen_ports)
cp = listen_ports;
else
cp = default_port;
while (cp != NULL) {
char *sep = strchr(cp, ',');
if (sep != NULL) {
*sep = 0;
}
transport = netsnmp_transport_open_server("snmptrap", cp);
if (transport == NULL) {
snmp_log(LOG_ERR, "couldn't open %s -- errno %d (\"%s\")\n",
cp, errno, strerror(errno));
snmptrapd_close_sessions(sess_list);
SOCK_CLEANUP;
exit(1);
} else {
ss = snmptrapd_add_session(transport);
if (ss == NULL) {
/*
* Shouldn't happen? We have already opened the transport
* successfully so what could have gone wrong?
*/
snmptrapd_close_sessions(sess_list);
netsnmp_transport_free(transport);
snmp_log(LOG_ERR, "couldn't open snmp - %s", strerror(errno));
SOCK_CLEANUP;
exit(1);
} else {
ss->next = sess_list;
sess_list = ss;
}
}
/*
* Process next listen address, if there is one.
*/
if (sep != NULL) {
*sep = ',';
cp = sep + 1;
} else {
cp = NULL;
}
}
SNMP_FREE(listen_ports); /* done with them */
#ifdef NETSNMP_USE_MYSQL
if( netsnmp_mysql_init() ) {
fprintf(stderr, "MySQL initialization failed\n");
exit(1);
}
#endif
#ifndef WIN32
/*
* fork the process to the background if we are not printing to stderr
*/
if (dofork && netsnmp_running) {
int fd;
switch (fork()) {
case -1:
fprintf(stderr, "bad fork - %s\n", strerror(errno));
_exit(1);
case 0:
/*
* become process group leader
*/
if (setsid() == -1) {
fprintf(stderr, "bad setsid - %s\n", strerror(errno));
_exit(1);
}
/*
* if we are forked, we don't want to print out to stdout or stderr
*/
fd = open("/dev/null", O_RDWR);
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
close(fd);
break;
default:
_exit(0);
}
}
#endif /* WIN32 */
#if HAVE_GETPID
if (pid_file != NULL) {
if ((PID = fopen(pid_file, "w")) == NULL) {
snmp_log_perror("fopen");
exit(1);
}
fprintf(PID, "%d\n", (int) getpid());
fclose(PID);
free_config_pidFile();
}
#endif
snmp_log(LOG_INFO, "NET-SNMP version %s\n", netsnmp_get_version());
/*
* ignore early sighup during startup
*/
reconfig = 0;
#if HAVE_UNISTD_H
#ifdef HAVE_SETGID
if ((gid = netsnmp_ds_get_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_GROUPID)) != 0) {
DEBUGMSGTL(("snmptrapd/main", "Changing gid to %d.\n", gid));
if (setgid(gid) == -1
#ifdef HAVE_SETGROUPS
|| setgroups(1, (gid_t *)&gid) == -1
#endif
) {
snmp_log_perror("setgid failed");
if (!netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_NO_ROOT_ACCESS)) {
exit(1);
}
}
}
#endif
#ifdef HAVE_SETUID
if ((uid = netsnmp_ds_get_int(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_USERID)) != 0) {
DEBUGMSGTL(("snmptrapd/main", "Changing uid to %d.\n", uid));
if (setuid(uid) == -1) {
snmp_log_perror("setuid failed");
if (!netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_NO_ROOT_ACCESS)) {
exit(1);
}
}
}
#endif
#endif
#ifdef WIN32SERVICE
trapd_status = SNMPTRAPD_RUNNING;
#endif
while (netsnmp_running) {
if (reconfig) {
/*
* If we are logging to a file, receipt of SIGHUP also
* indicates the the log file should be closed and
* re-opened. This is useful for users that want to
* rotate logs in a more predictable manner.
*/
netsnmp_logging_restart();
snmp_log(LOG_INFO, "NET-SNMP version %s restarted\n",
netsnmp_get_version());
trapd_update_config();
if (trap1_fmt_str_remember) {
parse_format( NULL, trap1_fmt_str_remember );
}
reconfig = 0;
}
numfds = 0;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_ZERO(&exceptfds);
block = 0;
tvp = &timeout;
timerclear(tvp);
tvp->tv_sec = 5;
snmp_select_info(&numfds, &readfds, tvp, &block);
if (block == 1)
tvp = NULL; /* block without timeout */
netsnmp_external_event_info(&numfds, &readfds, &writefds, &exceptfds);
count = select(numfds, &readfds, &writefds, &exceptfds, tvp);
gettimeofday(&Now, NULL);
if (count > 0) {
netsnmp_dispatch_external_events(&count, &readfds, &writefds,
&exceptfds);
/* If there are any more events after external events, then
* try SNMP events. */
if (count > 0) {
snmp_read(&readfds);
}
} else
switch (count) {
case 0:
snmp_timeout();
break;
case -1:
if (errno == EINTR)
continue;
snmp_log_perror("select");
netsnmp_running = 0;
break;
default:
fprintf(stderr, "select returned %d\n", count);
netsnmp_running = 0;
}
run_alarms();
}
if (snmp_get_do_logging()) {
struct tm *tm;
time_t timer;
time(&timer);
tm = localtime(&timer);
snmp_log(LOG_INFO,
"%.4d-%.2d-%.2d %.2d:%.2d:%.2d NET-SNMP version %s Stopped.\n",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
tm->tm_min, tm->tm_sec, netsnmp_get_version());
}
snmp_log(LOG_INFO, "Stopping snmptrapd\n");
#ifdef NETSNMP_EMBEDDED_PERL
shutdown_perl();
#endif
snmptrapd_close_sessions(sess_list);
snmp_shutdown("snmptrapd");
#ifdef WIN32SERVICE
trapd_status = SNMPTRAPD_STOPPED;
#endif
snmp_disable_log();
SOCK_CLEANUP;
return 0;
}
/*
* Read the configuration files. Implemented as a signal handler so that
* receipt of SIGHUP will cause configuration to be re-read when the
* trap daemon is running detatched from the console.
*
*/
void
trapd_update_config(void)
{
free_config();
#ifdef USING_MIBII_VACM_CONF_MODULE
vacm_standard_views(0,0,NULL,NULL);
#endif
read_configs();
}
#if !defined(HAVE_GETDTABLESIZE) && !defined(WIN32)
#include <sys/resource.h>
int
getdtablesize(void)
{
struct rlimit rl;
getrlimit(RLIMIT_NOFILE, &rl);
return (rl.rlim_cur);
}
#endif
/*
* Windows Service Related functions
*/
#ifdef WIN32SERVICE
/************************************************************
* main function for Windows
* Parse command line arguments for startup options,
* to start as service or console mode application in windows.
* Invokes appropriate startup functions depending on the
* parameters passed
*************************************************************/
int
__cdecl
_tmain(int argc, TCHAR * argv[])
{
/*
* Define Service Name and Description, which appears in windows SCM
*/
LPCTSTR lpszServiceName = app_name_long; /* Service Registry Name */
LPCTSTR lpszServiceDisplayName = _T("Net-SNMP Trap Handler"); /* Display Name */
LPCTSTR lpszServiceDescription =
#ifdef IFDESCR
_T("SNMPv2c / SNMPv3 trap/inform receiver from Net-SNMP. Supports MIB objects for IP,ICMP,TCP,UDP, and network interface sub-layers.");
#else
_T("SNMPv2c / SNMPv3 trap/inform receiver from Net-SNMP");
#endif
InputParams InputOptions;
int nRunType = RUN_AS_CONSOLE;
int quiet = 0;
nRunType = ParseCmdLineForServiceOption(argc, argv, &quiet);
switch (nRunType) {
case REGISTER_SERVICE:
/*
* Register As service
*/
InputOptions.Argc = argc;
InputOptions.Argv = argv;
exit (RegisterService(lpszServiceName,
lpszServiceDisplayName,
lpszServiceDescription, &InputOptions, quiet));
break;
case UN_REGISTER_SERVICE:
/*
* Unregister service
*/
exit (UnregisterService(lpszServiceName, quiet));
exit(0);
break;
case RUN_AS_SERVICE:
/*
* Run as service
*/
/*
* Register Stop Function
*/
RegisterStopFunction(StopSnmpTrapd);
return RunAsService(SnmpTrapdMain);
break;
default:
/*
* Run in console mode
*/
return SnmpTrapdMain(argc, argv);
break;
}
}
/*
* To stop Snmp Trap Receiver daemon
* This portion is still not working
*/
void
StopSnmpTrapd(void)
{
/*
* Shut Down Service
*/
term_handler(1);
/*
* Wait till trap receiver is completely stopped
*/
while (trapd_status != SNMPTRAPD_STOPPED) {
Sleep(100);
}
}
#endif /*WIN32SERVICE*/