blob: 37ca5abc0f9aa9ddb8fc715a38cfae39b6793615 [file] [log] [blame]
#include <net-snmp/net-snmp-config.h>
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <stdio.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#include <ctype.h>
#include <sys/types.h>
#if HAVE_WINSOCK_H
#include <winsock.h>
#else
#include <netinet/in.h>
#include <netdb.h>
#endif
#if HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#include <net-snmp/config_api.h>
#include <net-snmp/output_api.h>
#include <net-snmp/mib_api.h>
#include <net-snmp/utilities.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "utilities/execute.h"
#include "snmptrapd_handlers.h"
#include "snmptrapd_auth.h"
#include "snmptrapd_log.h"
#include "notification-log-mib/notification_log.h"
char *syslog_format1 = NULL;
char *syslog_format2 = NULL;
char *print_format1 = NULL;
char *print_format2 = NULL;
const char *trap1_std_str = "%.4y-%.2m-%.2l %.2h:%.2j:%.2k %B [%b] (via %A [%a]): %N\n\t%W Trap (%q) Uptime: %#T\n%v\n";
const char *trap2_std_str = "%.4y-%.2m-%.2l %.2h:%.2j:%.2k %B [%b]:\n%v\n";
void snmptrapd_free_traphandle(void);
const char *
trap_description(int trap)
{
switch (trap) {
case SNMP_TRAP_COLDSTART:
return "Cold Start";
case SNMP_TRAP_WARMSTART:
return "Warm Start";
case SNMP_TRAP_LINKDOWN:
return "Link Down";
case SNMP_TRAP_LINKUP:
return "Link Up";
case SNMP_TRAP_AUTHFAIL:
return "Authentication Failure";
case SNMP_TRAP_EGPNEIGHBORLOSS:
return "EGP Neighbor Loss";
case SNMP_TRAP_ENTERPRISESPECIFIC:
return "Enterprise Specific";
default:
return "Unknown Type";
}
}
void
snmptrapd_parse_traphandle(const char *token, char *line)
{
char buf[STRINGMAX];
oid obuf[MAX_OID_LEN];
size_t olen = MAX_OID_LEN;
char *cptr, *cp;
netsnmp_trapd_handler *traph;
int flags = 0;
memset( buf, 0, sizeof(buf));
memset(obuf, 0, sizeof(obuf));
cptr = copy_nword(line, buf, sizeof(buf));
if ( !cptr ) {
config_perror("Missing traphandle command");
return;
}
DEBUGMSGTL(("read_config:traphandle", "registering handler for: "));
if (!strcmp(buf, "default")) {
DEBUGMSG(("read_config:traphandle", "default"));
traph = netsnmp_add_default_traphandler( command_handler );
} else {
cp = buf+strlen(buf)-1;
if ( *cp == '*' ) {
flags |= NETSNMP_TRAPHANDLER_FLAG_MATCH_TREE;
*(cp--) = '\0';
if ( *cp == '.' ) {
/*
* Distinguish between 'oid.*' & 'oid*'
*/
flags |= NETSNMP_TRAPHANDLER_FLAG_STRICT_SUBTREE;
*(cp--) = '\0';
}
}
if (!read_objid(buf, obuf, &olen)) {
char buf1[STRINGMAX];
snprintf(buf1, sizeof(buf1),
"Bad trap OID in traphandle directive: %s", buf);
buf1[ sizeof(buf1)-1 ] = 0;
config_perror(buf1);
return;
}
DEBUGMSGOID(("read_config:traphandle", obuf, olen));
traph = netsnmp_add_traphandler( command_handler, obuf, olen );
}
DEBUGMSG(("read_config:traphandle", "\n"));
if (traph) {
traph->flags = flags;
traph->authtypes = TRAP_AUTH_EXE;
traph->token = strdup(cptr);
}
}
static void
parse_forward(const char *token, char *line)
{
char buf[STRINGMAX];
oid obuf[MAX_OID_LEN];
size_t olen = MAX_OID_LEN;
char *cptr, *cp;
netsnmp_trapd_handler *traph;
int flags = 0;
memset( buf, 0, sizeof(buf));
memset(obuf, 0, sizeof(obuf));
cptr = copy_nword(line, buf, sizeof(buf));
DEBUGMSGTL(("read_config:forward", "registering forward for: "));
if (!strcmp(buf, "default")) {
DEBUGMSG(("read_config:forward", "default"));
if ( !strcmp( cptr, "agentx" ))
traph = netsnmp_add_default_traphandler( axforward_handler );
else
traph = netsnmp_add_default_traphandler( forward_handler );
} else {
cp = buf+strlen(buf)-1;
if ( *cp == '*' ) {
flags |= NETSNMP_TRAPHANDLER_FLAG_MATCH_TREE;
*(cp--) = '\0';
if ( *cp == '.' ) {
/*
* Distinguish between 'oid.*' & 'oid*'
*/
flags |= NETSNMP_TRAPHANDLER_FLAG_STRICT_SUBTREE;
*(cp--) = '\0';
}
}
if (!read_objid(buf, obuf, &olen)) {
char buf1[STRINGMAX];
snprintf(buf1, sizeof(buf1),
"Bad trap OID in forward directive: %s", buf);
buf1[ sizeof(buf1)-1 ] = 0;
config_perror(buf1);
return;
}
DEBUGMSGOID(("read_config:forward", obuf, olen));
if ( !strcmp( cptr, "agentx" ))
traph = netsnmp_add_traphandler( axforward_handler, obuf, olen );
else
traph = netsnmp_add_traphandler( forward_handler, obuf, olen );
}
DEBUGMSG(("read_config:forward", "\n"));
if (traph) {
traph->flags = flags;
traph->authtypes = TRAP_AUTH_NET;
traph->token = strdup(cptr);
}
}
static void
parse_format(const char *token, char *line)
{
char *cp;
/*
* Extract the first token from the value
* which tells us which style of format this is
*/
cp = line;
while (*cp && !isspace(*cp))
cp++;
if (!(*cp)) {
/*
* If we haven't got anything left,
* then this entry is malformed.
* So report this, and give up
*/
return;
}
*(cp++) = '\0';
while (*cp && !isspace(*cp))
cp++;
/*
* OK - now "line" contains the format type,
* and cp points to the actual format string.
* So update the appropriate pointer(s).
*/
if (!strcmp( line, "print1")) {
SNMP_FREE( print_format1 );
print_format1 = strdup(cp);
} else if (!strcmp( line, "print2")) {
SNMP_FREE( print_format2 );
print_format2 = strdup(cp);
} else if (!strcmp( line, "print")) {
SNMP_FREE( print_format1 );
SNMP_FREE( print_format2 );
print_format1 = strdup(cp);
print_format2 = strdup(cp);
} else if (!strcmp( line, "syslog1")) {
SNMP_FREE( syslog_format1 );
syslog_format1 = strdup(cp);
} else if (!strcmp( line, "syslog2")) {
SNMP_FREE( syslog_format2 );
syslog_format2 = strdup(cp);
} else if (!strcmp( line, "syslog")) {
SNMP_FREE( syslog_format1 );
SNMP_FREE( syslog_format2 );
syslog_format1 = strdup(cp);
syslog_format2 = strdup(cp);
}
}
static void
parse_trap1_fmt(const char *token, char *line)
{
print_format1 = strdup(line);
}
void
free_trap1_fmt(void)
{
if (print_format1 && print_format1 != trap1_std_str)
free((char *) print_format1);
print_format1 = NULL;
}
static void
parse_trap2_fmt(const char *token, char *line)
{
print_format2 = strdup(line);
}
void
free_trap2_fmt(void)
{
if (print_format2 && print_format2 != trap2_std_str)
free((char *) print_format2);
print_format2 = NULL;
}
void
snmptrapd_register_configs( void )
{
register_config_handler("snmptrapd", "traphandle",
snmptrapd_parse_traphandle,
snmptrapd_free_traphandle,
"oid|\"default\" program [args ...] ");
register_config_handler("snmptrapd", "format1",
parse_trap1_fmt, free_trap1_fmt, "format");
register_config_handler("snmptrapd", "format2",
parse_trap2_fmt, free_trap2_fmt, "format");
register_config_handler("snmptrapd", "format",
parse_format, NULL,
"[print{,1,2}|syslog{,1,2}] format");
register_config_handler("snmptrapd", "forward",
parse_forward, NULL, "OID|\"default\" destination");
}
/*-----------------------------
*
* Routines to implement a "registry" of trap handlers
*
*-----------------------------*/
netsnmp_trapd_handler *netsnmp_auth_global_traphandlers = NULL;
netsnmp_trapd_handler *netsnmp_pre_global_traphandlers = NULL;
netsnmp_trapd_handler *netsnmp_post_global_traphandlers = NULL;
netsnmp_trapd_handler *netsnmp_default_traphandlers = NULL;
netsnmp_trapd_handler *netsnmp_specific_traphandlers = NULL;
/*
* Register a new "global" traphandler,
* to be applied to *all* incoming traps
*/
netsnmp_trapd_handler *
netsnmp_add_global_traphandler(int list, Netsnmp_Trap_Handler* handler) {
netsnmp_trapd_handler *traph;
if ( !handler )
return NULL;
traph = SNMP_MALLOC_TYPEDEF(netsnmp_trapd_handler);
if ( !traph )
return NULL;
/*
* Add this new handler to the front of the appropriate global list
* (or should it go on the end?)
*/
traph->handler = handler;
traph->authtypes = TRAP_AUTH_ALL; /* callers will likely change this */
switch (list) {
case NETSNMPTRAPD_AUTH_HANDLER:
traph->nexth = netsnmp_auth_global_traphandlers;
netsnmp_auth_global_traphandlers = traph;
break;
case NETSNMPTRAPD_PRE_HANDLER:
traph->nexth = netsnmp_pre_global_traphandlers;
netsnmp_pre_global_traphandlers = traph;
break;
case NETSNMPTRAPD_POST_HANDLER:
traph->nexth = netsnmp_post_global_traphandlers;
netsnmp_post_global_traphandlers = traph;
break;
default:
free( traph );
return NULL;
}
return traph;
}
/*
* Register a new "default" traphandler, to be applied to all
* traps with no specific trap handlers of their own.
*/
netsnmp_trapd_handler *
netsnmp_add_default_traphandler( Netsnmp_Trap_Handler* handler) {
netsnmp_trapd_handler *traph;
if ( !handler )
return NULL;
traph = SNMP_MALLOC_TYPEDEF(netsnmp_trapd_handler);
if ( !traph )
return NULL;
/*
* Add this new handler to the front of the default list
* (or should it go on the end?)
*/
traph->authtypes = TRAP_AUTH_ALL; /* callers will likely change this */
traph->handler = handler;
traph->nexth = netsnmp_default_traphandlers;
netsnmp_default_traphandlers = traph;
return traph;
}
/*
* Register a new trap-specific traphandler
*/
netsnmp_trapd_handler *
netsnmp_add_traphandler(Netsnmp_Trap_Handler* handler,
oid *trapOid, int trapOidLen ) {
netsnmp_trapd_handler *traph, *traph2;
if ( !handler )
return NULL;
traph = SNMP_MALLOC_TYPEDEF(netsnmp_trapd_handler);
if ( !traph )
return NULL;
/*
* Populate this new handler with the trap information
* (NB: the OID fields were not used in the default/global lists)
*/
traph->authtypes = TRAP_AUTH_ALL; /* callers will likely change this */
traph->handler = handler;
traph->trapoid_len = trapOidLen;
traph->trapoid = netsnmp_memdup(trapOid, sizeof(oid) * trapOidLen);
/*
* Now try to find the appropriate place in the trap-specific
* list for this particular trap OID. If there's a matching OID
* already, then find it. Otherwise find the one that follows.
* If we run out of entried, the new one should be tacked onto the end.
*/
for (traph2 = netsnmp_specific_traphandlers;
traph2; traph2 = traph2->nextt) {
/* XXX - check this! */
if (snmp_oid_compare(traph2->trapoid, traph2->trapoid_len,
trapOid, trapOidLen) <= 0)
break;
}
if (traph2) {
/*
* OK - We've either got an exact match, or we've found the
* entry *after* where the new one should go.
*/
if (!snmp_oid_compare(traph->trapoid, traph->trapoid_len,
traph2->trapoid, traph2->trapoid_len)) {
/*
* Exact match, so find the end of the *handler* list
* and tack on this new entry...
*/
while (traph2->nexth)
traph2 = traph2->nexth;
traph2->nexth = traph;
traph->nextt = traph2->nextt; /* Might as well... */
traph->prevt = traph2->prevt;
} else {
/*
* .. or the following entry, so insert the new one before it.
*/
traph->prevt = traph2->prevt;
if (traph2->prevt)
traph2->prevt->nextt = traph;
else
netsnmp_specific_traphandlers = traph;
traph2->prevt = traph;
traph->nextt = traph2;
}
} else {
/*
* If we've run out of entries without finding a suitable spot,
* the new one should be tacked onto the end.....
*/
if (netsnmp_specific_traphandlers) {
traph2 = netsnmp_specific_traphandlers;
while (traph2->nextt)
traph2 = traph2->nextt;
traph2->nextt = traph;
traph->prevt = traph2;
} else {
/*
* .... unless this is the very first entry, of course!
*/
netsnmp_specific_traphandlers = traph;
}
}
return traph;
}
void
snmptrapd_free_traphandle(void)
{
netsnmp_trapd_handler *traph = NULL, *nextt = NULL, *nexth = NULL;
DEBUGMSGTL(("snmptrapd", "Freeing trap handler lists\n"));
/*
* Free default trap handlers
*/
traph = netsnmp_default_traphandlers;
/* loop over handlers */
while (traph) {
DEBUGMSG(("snmptrapd", "Freeing default trap handler\n"));
nexth = traph->nexth;
SNMP_FREE(traph->token);
SNMP_FREE(traph);
traph = nexth;
}
netsnmp_default_traphandlers = NULL;
/*
* Free specific trap handlers
*/
traph = netsnmp_specific_traphandlers;
/* loop over traps */
while (traph) {
nextt = traph->nextt;
/* loop over handlers for this trap */
while (traph) {
DEBUGMSG(("snmptrapd", "Freeing specific trap handler\n"));
nexth = traph->nexth;
SNMP_FREE(traph->token);
SNMP_FREE(traph->trapoid);
SNMP_FREE(traph);
traph = nexth;
}
traph = nextt;
}
netsnmp_specific_traphandlers = NULL;
}
/*
* Locate the list of handlers for this particular Trap OID
* Returns NULL if there are no relevant traps
*/
netsnmp_trapd_handler *
netsnmp_get_traphandler( oid *trapOid, int trapOidLen ) {
netsnmp_trapd_handler *traph;
if (!trapOid || !trapOidLen)
return NULL;
/*
* Look for a matching OID, and return that list...
*/
for (traph = netsnmp_specific_traphandlers;
traph; traph=traph->nextt ) {
/*
* If the trap handler wasn't wildcarded, then the trapOID
* should match the registered OID exactly.
*/
if (!(traph->flags & NETSNMP_TRAPHANDLER_FLAG_MATCH_TREE)) {
if (snmp_oid_compare(traph->trapoid, traph->trapoid_len,
trapOid, trapOidLen) == 0) {
DEBUGMSGTL(( "snmptrapd", "get_traphandler exact match (%x)\n", traph));
return traph;
}
} else {
/*
* If the trap handler *was* wildcarded, then the trapOID
* should have the registered OID as a prefix...
*/
if (snmp_oidsubtree_compare(traph->trapoid,
traph->trapoid_len,
trapOid, trapOidLen) == 0) {
if (traph->flags & NETSNMP_TRAPHANDLER_FLAG_STRICT_SUBTREE) {
/*
* ... and (optionally) *strictly* as a prefix
* i.e. not including an exact match.
*/
if (snmp_oid_compare(traph->trapoid, traph->trapoid_len,
trapOid, trapOidLen) != 0) {
DEBUGMSGTL(( "snmptrapd", "get_traphandler strict subtree match (%x)\n", traph));
return traph;
}
} else {
DEBUGMSGTL(( "snmptrapd", "get_traphandler subtree match (%x)\n", traph));
return traph;
}
}
}
}
/*
* .... or failing that, return the "default" list (which may be NULL)
*/
DEBUGMSGTL(( "snmptrapd", "get_traphandler default (%x)\n",
netsnmp_default_traphandlers));
return netsnmp_default_traphandlers;
}
/*-----------------------------
*
* Standard traphandlers for the common requirements
*
*-----------------------------*/
#define SYSLOG_V1_STANDARD_FORMAT "%a: %W Trap (%q) Uptime: %#T%#v\n"
#define SYSLOG_V1_ENTERPRISE_FORMAT "%a: %W Trap (%q) Uptime: %#T%#v\n" /* XXX - (%q) become (.N) ??? */
#define SYSLOG_V23_NOTIFICATION_FORMAT "%B [%b]: Trap %#v\n" /* XXX - introduces a leading " ," */
/*
* Trap handler for logging via syslog
*/
int syslog_handler( netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
u_char *rbuf = NULL;
size_t r_len = 64, o_len = 0;
int trunc = 0;
extern int SyslogTrap;
DEBUGMSGTL(( "snmptrapd", "syslog_handler\n"));
if (SyslogTrap)
return NETSNMPTRAPD_HANDLER_OK;
if ((rbuf = (u_char *) calloc(r_len, 1)) == NULL) {
snmp_log(LOG_ERR, "couldn't display trap -- malloc failed\n");
return NETSNMPTRAPD_HANDLER_FAIL; /* Failed but keep going */
}
/*
* If there's a format string registered for this trap, then use it.
*/
if (handler && handler->format) {
DEBUGMSGTL(( "snmptrapd", "format = '%s'\n", handler->format));
if (*handler->format) {
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
handler->format, pdu, transport);
} else {
free(rbuf);
return NETSNMPTRAPD_HANDLER_OK; /* A 0-length format string means don't log */
}
/*
* Otherwise (i.e. a NULL handler format string),
* use a standard output format setting
* either configurable, or hardwired
*
* XXX - v1 traps use a different hardwired formats for
* standard and enterprise specific traps
* Do we actually need this?
*/
} else {
if ( pdu->command == SNMP_MSG_TRAP ) {
if (syslog_format1) {
DEBUGMSGTL(( "snmptrapd", "syslog_format v1 = '%s'\n", syslog_format1));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
syslog_format1, pdu, transport);
} else if (pdu->trap_type == SNMP_TRAP_ENTERPRISESPECIFIC) {
DEBUGMSGTL(( "snmptrapd", "v1 enterprise format\n"));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
SYSLOG_V1_ENTERPRISE_FORMAT,
pdu, transport);
} else {
DEBUGMSGTL(( "snmptrapd", "v1 standard trap format\n"));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
SYSLOG_V1_STANDARD_FORMAT,
pdu, transport);
}
} else { /* SNMPv2/3 notifications */
if (syslog_format2) {
DEBUGMSGTL(( "snmptrapd", "syslog_format v1 = '%s'\n", syslog_format2));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
syslog_format2, pdu, transport);
} else {
DEBUGMSGTL(( "snmptrapd", "v2/3 format\n"));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
SYSLOG_V23_NOTIFICATION_FORMAT,
pdu, transport);
}
}
}
snmp_log(LOG_WARNING, "%s%s", rbuf, (trunc?" [TRUNCATED]\n":""));
free(rbuf);
return NETSNMPTRAPD_HANDLER_OK;
}
#define PRINT_V23_NOTIFICATION_FORMAT "%.4y-%.2m-%.2l %.2h:%.2j:%.2k %B [%b]:\n%v\n"
/*
* Trap handler for logging to a file
*/
int print_handler( netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
u_char *rbuf = NULL;
size_t r_len = 64, o_len = 0;
int trunc = 0;
extern int dropauth;
DEBUGMSGTL(( "snmptrapd", "print_handler\n"));
/*
* Don't bother logging authentication failures
* XXX - can we handle this via suitable handler entries instead?
*/
if (pdu->trap_type == SNMP_TRAP_AUTHFAIL && dropauth)
return NETSNMPTRAPD_HANDLER_OK;
if ((rbuf = (u_char *) calloc(r_len, 1)) == NULL) {
snmp_log(LOG_ERR, "couldn't display trap -- malloc failed\n");
return NETSNMPTRAPD_HANDLER_FAIL; /* Failed but keep going */
}
/*
* If there's a format string registered for this trap, then use it.
*/
if (handler && handler->format) {
DEBUGMSGTL(( "snmptrapd", "format = '%s'\n", handler->format));
if (*handler->format) {
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
handler->format, pdu, transport);
} else {
free(rbuf);
return NETSNMPTRAPD_HANDLER_OK; /* A 0-length format string means don't log */
}
/*
* Otherwise (i.e. a NULL handler format string),
* use a standard output format setting
* either configurable, or hardwired
*
* XXX - v1 traps use a different routine for hardwired output
* Do we actually need this separate v1 routine?
* Or would a suitable format string be sufficient?
*/
} else {
if ( pdu->command == SNMP_MSG_TRAP ) {
if (print_format1) {
DEBUGMSGTL(( "snmptrapd", "print_format v1 = '%s'\n", print_format1));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
print_format1, pdu, transport);
} else {
DEBUGMSGTL(( "snmptrapd", "v1 format\n"));
trunc = !realloc_format_plain_trap(&rbuf, &r_len, &o_len, 1,
pdu, transport);
}
} else {
if (print_format2) {
DEBUGMSGTL(( "snmptrapd", "print_format v2 = '%s'\n", print_format2));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
print_format2, pdu, transport);
} else {
DEBUGMSGTL(( "snmptrapd", "v2/3 format\n"));
trunc = !realloc_format_trap(&rbuf, &r_len, &o_len, 1,
PRINT_V23_NOTIFICATION_FORMAT,
pdu, transport);
}
}
}
snmp_log(LOG_INFO, "%s%s", rbuf, (trunc?" [TRUNCATED]\n":""));
free(rbuf);
return NETSNMPTRAPD_HANDLER_OK;
}
/*
* Trap handler for invoking a suitable script
*/
void
send_handler_data(FILE * file, struct hostent *host,
netsnmp_pdu *pdu, netsnmp_transport *transport)
{
netsnmp_variable_list tmpvar, *vars;
static oid trapoids[] = { 1, 3, 6, 1, 6, 3, 1, 1, 5, 0 };
static oid snmpsysuptime[] = { 1, 3, 6, 1, 2, 1, 1, 3, 0 };
static oid snmptrapoid[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
static oid snmptrapent[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 3, 0 };
static oid snmptrapaddr[] = { 1, 3, 6, 1, 6, 3, 18, 1, 3, 0 };
static oid snmptrapcom[] = { 1, 3, 6, 1, 6, 3, 18, 1, 4, 0 };
oid enttrapoid[MAX_OID_LEN];
int enttraplen = pdu->enterprise_length;
if (transport != NULL && transport->f_fmtaddr != NULL) {
char *tstr = transport->f_fmtaddr(transport, pdu->transport_data,
pdu->transport_data_length);
if (tstr != NULL) {
fprintf(file, "%s\n%s\n", host ? host->h_name : tstr, tstr);
free(tstr);
}
} else {
fprintf(file, "%s\n<UNKNOWN>\n", host ? host->h_name : "<UNKNOWN>");
}
if (pdu->command == SNMP_MSG_TRAP) {
/*
* convert a v1 trap to a v2 variable binding list:
* The uptime and trapOID go first in the list.
*/
tmpvar.val.integer = (long *) &pdu->time;
tmpvar.val_len = sizeof(pdu->time);
tmpvar.type = ASN_TIMETICKS;
fprint_variable(file, snmpsysuptime,
sizeof(snmpsysuptime) / sizeof(oid), &tmpvar);
tmpvar.type = ASN_OBJECT_ID;
if (pdu->trap_type == SNMP_TRAP_ENTERPRISESPECIFIC) {
memcpy(enttrapoid, pdu->enterprise, sizeof(oid) * enttraplen);
if (enttrapoid[enttraplen - 1] != 0)
enttrapoid[enttraplen++] = 0;
enttrapoid[enttraplen++] = pdu->specific_type;
tmpvar.val.objid = enttrapoid;
tmpvar.val_len = enttraplen * sizeof(oid);
} else {
trapoids[9] = pdu->trap_type + 1;
tmpvar.val.objid = trapoids;
tmpvar.val_len = 10 * sizeof(oid);
}
fprint_variable(file, snmptrapoid,
sizeof(snmptrapoid) / sizeof(oid), &tmpvar);
}
/*
* do the variables in the pdu
*/
for (vars = pdu->variables; vars; vars = vars->next_variable) {
fprint_variable(file, vars->name, vars->name_length, vars);
}
if (pdu->command == SNMP_MSG_TRAP) {
/*
* convert a v1 trap to a v2 variable binding list:
* The enterprise goes last.
*/
tmpvar.val.string = pdu->agent_addr;
tmpvar.val_len = 4;
tmpvar.type = ASN_IPADDRESS;
fprint_variable(file, snmptrapaddr,
sizeof(snmptrapaddr) / sizeof(oid), &tmpvar);
tmpvar.val.string = pdu->community;
tmpvar.val_len = pdu->community_len;
tmpvar.type = ASN_OCTET_STR;
fprint_variable(file, snmptrapcom,
sizeof(snmptrapcom) / sizeof(oid), &tmpvar);
tmpvar.val.objid = pdu->enterprise;
tmpvar.val_len = pdu->enterprise_length * sizeof(oid);
tmpvar.type = ASN_OBJECT_ID;
fprint_variable(file, snmptrapent,
sizeof(snmptrapent) / sizeof(oid), &tmpvar);
}
}
void
do_external(char *cmd, struct hostent *host,
netsnmp_pdu *pdu, netsnmp_transport *transport)
{
FILE *file;
int oldquick, result;
DEBUGMSGTL(("snmptrapd", "Running: %s\n", cmd));
oldquick = snmp_get_quick_print();
snmp_set_quick_print(1);
if (cmd) {
#ifndef WIN32
int fd[2];
int pid;
if (pipe(fd)) {
snmp_log_perror("pipe");
}
if ((pid = fork()) == 0) {
/*
* child
*/
close(0);
if (dup(fd[0]) != 0) {
snmp_log_perror("dup");
}
close(fd[1]);
close(fd[0]);
system(cmd);
exit(0);
} else if (pid > 0) {
file = fdopen(fd[1], "w");
send_handler_data(file, host, pdu, transport);
fclose(file);
close(fd[0]);
close(fd[1]);
if (waitpid(pid, &result, 0) < 0) {
snmp_log_perror("waitpid");
}
} else {
snmp_log_perror("fork");
}
#else
char command_buf[128];
char file_buf[L_tmpnam];
tmpnam(file_buf);
file = fopen(file_buf, "w");
if (!file) {
fprintf(stderr, "fopen: %s: %s\n", file_buf, strerror(errno));
} else {
send_handler_data(file, host, pdu, transport);
fclose(file);
snprintf(command_buf, sizeof(command_buf),
"%s < %s", cmd, file_buf);
command_buf[ sizeof(command_buf)-1 ] = 0;
result = system(command_buf);
if (result == -1)
fprintf(stderr, "system: %s: %s\n", command_buf,
strerror(errno));
else if (result)
fprintf(stderr, "system: %s: %d\n", command_buf, result);
remove(file_buf);
}
#endif /* WIN32 */
}
snmp_set_quick_print(oldquick);
}
#define EXECUTE_FORMAT "%B\n%b\n%V\n%v\n"
int command_handler( netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
u_char *rbuf = NULL;
size_t r_len = 64, o_len = 0;
int oldquick;
DEBUGMSGTL(( "snmptrapd", "command_handler\n"));
DEBUGMSGTL(( "snmptrapd", "token = '%s'\n", handler->token));
if (handler && handler->token && *handler->token) {
netsnmp_pdu *v2_pdu = NULL;
if (pdu->command == SNMP_MSG_TRAP)
v2_pdu = convert_v1pdu_to_v2(pdu);
else
v2_pdu = pdu;
oldquick = snmp_get_quick_print();
snmp_set_quick_print(1);
/*
* Format the trap and pass this string to the external command
*/
if ((rbuf = (u_char *) calloc(r_len, 1)) == NULL) {
snmp_log(LOG_ERR, "couldn't display trap -- malloc failed\n");
return NETSNMPTRAPD_HANDLER_FAIL; /* Failed but keep going */
}
/*
* If there's a format string registered for this trap, then use it.
* Otherwise use the standard execution format setting.
*/
if (handler && handler->format && *handler->format) {
DEBUGMSGTL(( "snmptrapd", "format = '%s'\n", handler->format));
realloc_format_trap(&rbuf, &r_len, &o_len, 1,
handler->format,
v2_pdu, transport);
} else {
DEBUGMSGTL(( "snmptrapd", "execute format\n"));
realloc_format_trap(&rbuf, &r_len, &o_len, 1,
EXECUTE_FORMAT,
v2_pdu, transport);
}
/*
* and pass this formatted string to the command specified
*/
run_shell_command(handler->token, (char*)rbuf, NULL, 0); /* Not interested in output */
snmp_set_quick_print(oldquick);
if (pdu->command == SNMP_MSG_TRAP)
snmp_free_pdu(v2_pdu);
free(rbuf);
}
return NETSNMPTRAPD_HANDLER_OK;
}
/*
* Trap handler for doing something with "event" traps
* (not entirely clear what this is about ???)
*/
/* XXX - in snmptrapd.c */
void event_input(netsnmp_variable_list * vp);
int event_handler( netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
DEBUGMSGTL(( "snmptrapd", "event_handler\n"));
event_input(pdu->variables);
return NETSNMPTRAPD_HANDLER_OK;
}
/*
* Trap handler for forwarding to the AgentX master agent
*/
int axforward_handler( netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
send_v2trap( pdu->variables );
return NETSNMPTRAPD_HANDLER_OK;
}
/*
* Trap handler for forwarding to another destination
*/
int forward_handler( netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
netsnmp_session session, *ss;
netsnmp_pdu *pdu2;
char buf[BUFSIZ], *cp;
DEBUGMSGTL(( "snmptrapd", "forward_handler (%s)\n", handler->token));
snmp_sess_init( &session );
if (strchr( handler->token, ':') == NULL) {
snprintf( buf, BUFSIZ, "%s:%d", handler->token, SNMP_TRAP_PORT);
cp = buf;
} else {
cp = handler->token;
}
session.peername = cp;
session.version = pdu->version;
ss = snmp_open( &session );
if (!ss)
return NETSNMPTRAPD_HANDLER_FAIL;
/* XXX: wjh we should be caching sessions here and not always
reopening a session. It's very ineffecient, especially with v3
INFORMS which may require engineID probing */
pdu2 = snmp_clone_pdu(pdu);
if (pdu2->transport_data) {
free(pdu2->transport_data);
pdu2->transport_data = NULL;
pdu2->transport_data_length = 0;
}
if (!snmp_send( ss, pdu2 )) {
snmp_sess_perror("Forward failed", ss);
snmp_free_pdu(pdu2);
}
snmp_close( ss );
return NETSNMPTRAPD_HANDLER_OK;
}
#if defined(USING_NOTIFICATION_LOG_MIB_NOTIFICATION_LOG_MODULE) && defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(NETSNMP_SNMPTRAPD_DISABLE_AGENTX)
/*
* "Notification" handler for implementing NOTIFICATION-MIB
* (presumably)
*/
int notification_handler(netsnmp_pdu *pdu,
netsnmp_transport *transport,
netsnmp_trapd_handler *handler)
{
DEBUGMSGTL(( "snmptrapd", "notification_handler\n"));
log_notification(pdu, transport);
return NETSNMPTRAPD_HANDLER_OK;
}
#endif
/*-----------------------------
*
* Main driving code, to process an incoming trap
*
*-----------------------------*/
int
snmp_input(int op, netsnmp_session *session,
int reqid, netsnmp_pdu *pdu, void *magic)
{
oid stdTrapOidRoot[] = { 1, 3, 6, 1, 6, 3, 1, 1, 5 };
oid snmpTrapOid[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
oid trapOid[MAX_OID_LEN+2] = {0};
int trapOidLen;
netsnmp_variable_list *vars;
netsnmp_trapd_handler *traph;
netsnmp_transport *transport = (netsnmp_transport *) magic;
int ret;
extern netsnmp_trapd_handler *netsnmp_auth_global_traphandlers;
extern netsnmp_trapd_handler *netsnmp_pre_global_traphandlers;
extern netsnmp_trapd_handler *netsnmp_post_global_traphandlers;
switch (op) {
case NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE:
/*
* Drops packets with reception problems
*/
if (session->s_snmp_errno) {
/* drop problem packets */
return 1;
}
/*
* Determine the OID that identifies the trap being handled
*/
DEBUGMSGTL(("snmptrapd", "input: %x\n", pdu->command));
switch (pdu->command) {
case SNMP_MSG_TRAP:
/*
* Convert v1 traps into a v2-style trap OID
* (following RFC 2576)
*/
if (pdu->trap_type == SNMP_TRAP_ENTERPRISESPECIFIC) {
trapOidLen = pdu->enterprise_length;
memcpy(trapOid, pdu->enterprise, sizeof(oid) * trapOidLen);
if (trapOid[trapOidLen - 1] != 0) {
trapOid[trapOidLen++] = 0;
}
trapOid[trapOidLen++] = pdu->specific_type;
} else {
memcpy(trapOid, stdTrapOidRoot, sizeof(stdTrapOidRoot));
trapOidLen = OID_LENGTH(stdTrapOidRoot); /* 9 */
trapOid[trapOidLen++] = pdu->trap_type+1;
}
break;
case SNMP_MSG_TRAP2:
case SNMP_MSG_INFORM:
/*
* v2c/v3 notifications *should* have snmpTrapOID as the
* second varbind, so we can go straight there.
* But check, just to make sure
*/
vars = pdu->variables;
if (vars)
vars = vars->next_variable;
if (!vars || snmp_oid_compare(vars->name, vars->name_length,
snmpTrapOid, OID_LENGTH(snmpTrapOid))) {
/*
* Didn't find it!
* Let's look through the full list....
*/
for ( vars = pdu->variables; vars; vars=vars->next_variable) {
if (!snmp_oid_compare(vars->name, vars->name_length,
snmpTrapOid, OID_LENGTH(snmpTrapOid)))
break;
}
if (!vars) {
/*
* Still can't find it! Give up.
*/
snmp_log(LOG_ERR, "Cannot find TrapOID in TRAP2 PDU\n");
return 1; /* ??? */
}
}
memcpy(trapOid, vars->val.objid, vars->val_len);
trapOidLen = vars->val_len /sizeof(oid);
break;
default:
/* SHOULDN'T HAPPEN! */
return 1; /* ??? */
}
DEBUGMSGTL(( "snmptrapd", "Trap OID: "));
DEBUGMSGOID(("snmptrapd", trapOid, trapOidLen));
DEBUGMSG(( "snmptrapd", "\n"));
/*
* OK - We've found the Trap OID used to identify this trap.
* Call each of the various lists of handlers:
* a) authentication-related handlers,
* b) other handlers to be applied to all traps
* (*before* trap-specific handlers)
* c) the handler(s) specific to this trap
t * d) any other global handlers
*
* In each case, a particular trap handler can abort further
* processing - either just for that particular list,
* or for the trap completely.
*
* This is particularly designed for authentication-related
* handlers, but can also be used elsewhere.
*
* OK - Enough waffling, let's get to work.....
*/
/*
* a) authentication handlers
*/
traph = netsnmp_auth_global_traphandlers;
DEBUGMSGTL(("snmptrapd", "Running auth trap handlers\n"));
while (traph) {
if (!netsnmp_trapd_check_auth(traph->authtypes)) {
traph = traph->nexth;
continue; /* we continue on and skip this one */
}
ret = (*(traph->handler))(pdu, transport, traph);
if (ret == NETSNMPTRAPD_HANDLER_FINISH)
return 1;
if (ret == NETSNMPTRAPD_HANDLER_BREAK)
break;
traph = traph->nexth;
}
/*
* b) pre-specific global handlers
*/
traph = netsnmp_pre_global_traphandlers;
DEBUGMSGTL(("snmptrapd", "Running pre-global trap handlers\n"));
while (traph) {
if (!netsnmp_trapd_check_auth(traph->authtypes)) {
traph = traph->nexth;
continue; /* we continue on and skip this one */
}
ret = (*(traph->handler))(pdu, transport, traph);
if (ret == NETSNMPTRAPD_HANDLER_FINISH)
return 1;
if (ret == NETSNMPTRAPD_HANDLER_BREAK)
break;
traph = traph->nexth;
}
/*
* c) trap-specific handlers
*/
DEBUGMSGTL(("snmptrapd", "Running trap specific handlers\n"));
traph = netsnmp_get_traphandler(trapOid, trapOidLen);
while (traph) {
if (!netsnmp_trapd_check_auth(traph->authtypes)) {
traph = traph->nexth;
continue; /* we continue on and skip this one */
}
ret = (*(traph->handler))(pdu, transport, traph);
if (ret == NETSNMPTRAPD_HANDLER_FINISH)
return 1;
if (ret == NETSNMPTRAPD_HANDLER_BREAK)
break;
traph = traph->nexth;
}
/*
* d) other global handlers
*/
DEBUGMSGTL(("snmptrapd", "Running global handlers\n"));
traph = netsnmp_post_global_traphandlers;
while (traph) {
if (!netsnmp_trapd_check_auth(traph->authtypes)) {
traph = traph->nexth;
continue; /* we continue on and skip this one */
}
ret = (*(traph->handler))(pdu, transport, traph);
if (ret == NETSNMPTRAPD_HANDLER_FINISH)
return 1;
if (ret == NETSNMPTRAPD_HANDLER_BREAK)
break;
traph = traph->nexth;
}
if (pdu->command == SNMP_MSG_INFORM) {
netsnmp_pdu *reply = snmp_clone_pdu(pdu);
if (!reply) {
snmp_log(LOG_ERR, "couldn't clone PDU for INFORM response\n");
} else {
reply->command = SNMP_MSG_RESPONSE;
reply->errstat = 0;
reply->errindex = 0;
if (!snmp_send(session, reply)) {
snmp_sess_perror("snmptrapd: Couldn't respond to inform pdu",
session);
snmp_free_pdu(reply);
}
}
}
break;
case NETSNMP_CALLBACK_OP_TIMED_OUT:
snmp_log(LOG_ERR, "Timeout: This shouldn't happen!\n");
break;
case NETSNMP_CALLBACK_OP_SEND_FAILED:
snmp_log(LOG_ERR, "Send Failed: This shouldn't happen either!\n");
break;
case NETSNMP_CALLBACK_OP_CONNECT:
case NETSNMP_CALLBACK_OP_DISCONNECT:
/* Ignore silently */
break;
default:
snmp_log(LOG_ERR, "Unknown operation (%d): This shouldn't happen!\n", op);
break;
}
return 0;
}