#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-features.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_NETINET_IN_H

#include <netinet/in.h>

#endif

#if HAVE_NETDB_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"

netsnmp_feature_child_of(add_default_traphandler, snmptrapd)

char *syslog_format1 = NULL;

char *syslog_format2 = NULL;

char *print_format1  = NULL;

char *print_format2  = NULL;

char *exec_format1   = NULL;

char *exec_format2   = NULL;

int   SyslogTrap = 0;

int   dropauth = 0;

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;

    char           *format = NULL;

    memset( buf, 0, sizeof(buf));

    memset(obuf, 0, sizeof(obuf));

    cptr = copy_nword(line, buf, sizeof(buf));

    if ( buf[0] == '-' && buf[1] == 'F' ) {

        cptr = copy_nword(cptr, buf, sizeof(buf));

        format = strdup( buf );

        cptr = copy_nword(cptr, buf, sizeof(buf));

    }

    if ( !cptr ) {

        netsnmp_config_error("Missing traphandle command (%s)", buf);

        free(format);

        return;

    }

    DEBUGMSGTL(("read_config:traphandle", "registering handler for: "));

    if (!strcmp(buf, "default")) {

        DEBUGMSG(("read_config:traphandle", "default"));

        traph = netsnmp_add_global_traphandler(NETSNMPTRAPD_DEFAULT_HANDLER,

                                               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)) {

	    netsnmp_config_error("Bad trap OID in traphandle directive: %s",

				 buf);

            free(format);

            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);

        if (format) {

            traph->format = format;

            format = NULL;

        }

    }

    free(format);

}

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;

    char           *format = NULL;

    memset( buf, 0, sizeof(buf));

    memset(obuf, 0, sizeof(obuf));

    cptr = copy_nword(line, buf, sizeof(buf));

    if ( buf[0] == '-' && buf[1] == 'F' ) {

        cptr = copy_nword(cptr, buf, sizeof(buf));

        format = strdup( buf );

        cptr = copy_nword(cptr, 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_global_traphandler(NETSNMPTRAPD_DEFAULT_HANDLER,

                                            axforward_handler );

        else

            traph = netsnmp_add_global_traphandler(NETSNMPTRAPD_DEFAULT_HANDLER,

                                            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)) {

	    netsnmp_config_error("Bad trap OID in forward directive: %s", buf);

            free(format);

            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);

        if (format)

            traph->format = format;

    } else {

        free(format);

    }

}

void

parse_format(const char *token, char *line)

{

    char *cp, *sep;

    /*

     * Extract the first token from the value

     * which tells us which style of format this is

     */

    cp = line;

    while (*cp && !isspace((unsigned char)(*cp)))

        cp++;

    if (!(*cp)) {

        /*

	 * If we haven't got anything left,

	 * then this entry is malformed.

	 * So report this, and give up

	 */

        return;

    }

    sep = cp;

    *(cp++) = '\0';

    while (*cp && isspace((unsigned char)(*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);

    } else if (!strcmp( line, "execute1")) {

        SNMP_FREE( exec_format1 );

        exec_format1 = strdup(cp);

    } else if (!strcmp( line, "execute2")) {

        SNMP_FREE( exec_format2 );

        exec_format2 = strdup(cp);

    } else if (!strcmp( line, "execute")) {

        SNMP_FREE( exec_format1 );

        SNMP_FREE( exec_format2 );

        exec_format1 = strdup(cp);

        exec_format2 = strdup(cp);

    }

    *sep = ' ';

}

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}|execute{,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;

typedef struct netsnmp_handler_map_t {

   netsnmp_trapd_handler **handler;

   const char             *descr;

} netsnmp_handler_map;

static netsnmp_handler_map handlers[] = {

    { &netsnmp_auth_global_traphandlers, "auth trap" },

    { &netsnmp_pre_global_traphandlers, "pre-global trap" },

    { NULL, "trap specific" },

    { &netsnmp_post_global_traphandlers, "global" },

    { NULL, 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 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;

    case NETSNMPTRAPD_DEFAULT_HANDLER:

        traph->nexth   = netsnmp_default_traphandlers;

        netsnmp_default_traphandlers = traph;

        break;

    default:

        free( traph );

        return NULL;

    }

    return traph;

}

#ifndef NETSNMP_FEATURE_REMOVE_ADD_DEFAULT_TRAPHANDLER

/*

 * 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) {

    return netsnmp_add_global_traphandler(NETSNMPTRAPD_DEFAULT_HANDLER,

                                          handler);

}

#endif /* NETSNMP_FEATURE_REMOVE_ADD_DEFAULT_TRAPHANDLER */

/*

 * 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     = snmp_duplicate_objid(trapOid, 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) {

        DEBUGMSGTL(( "snmptrapd:lookup", "get_traphandler no OID!\n"));

        return NULL;

    }

    DEBUGMSGTL(( "snmptrapd:lookup", "Looking up Trap OID: "));

    DEBUGMSGOID(("snmptrapd:lookup", trapOid, trapOidLen));

    DEBUGMSG(( "snmptrapd:lookup", "\n"));

    /*

     * 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:lookup",

                             "get_traphandler exact match (%p)\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:lookup", "get_traphandler strict subtree match (%p)\n", traph));

	                return traph;

                    }

                } else {

                    DEBUGMSGTL(( "snmptrapd:lookup", "get_traphandler subtree match (%p)\n", traph));

	            return traph;

                }

            }

	}

    }

    /*

     * .... or failing that, return the "default" list (which may be NULL)

     */

    DEBUGMSGTL(( "snmptrapd:lookup", "get_traphandler default (%p)\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;

    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;

    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;

}

#define EXECUTE_FORMAT	"%B\n%b\n%V\n%v\n"

/*

 *  Trap handler for invoking a suitable script

 */

int   command_handler( netsnmp_pdu           *pdu,

                       netsnmp_transport     *transport,

                       netsnmp_trapd_handler *handler)

{

#ifndef USING_UTILITIES_EXECUTE_MODULE

    NETSNMP_LOGONCE((LOG_WARNING,

                     "support for run_shell_command not available\n"));

    return NETSNMPTRAPD_HANDLER_FAIL;

#else

    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 = netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, 

                                          NETSNMP_DS_LIB_QUICK_PRINT);

        netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, 

                               NETSNMP_DS_LIB_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 {

	    if ( pdu->command == SNMP_MSG_TRAP && exec_format1 ) {

                DEBUGMSGTL(( "snmptrapd", "exec v1 = '%s'\n", exec_format1));

                realloc_format_trap(&rbuf, &r_len, &o_len, 1,

                                             exec_format1, pdu, transport);

	    } else if ( pdu->command != SNMP_MSG_TRAP && exec_format2 ) {

                DEBUGMSGTL(( "snmptrapd", "exec v2/3 = '%s'\n", exec_format2));

                realloc_format_trap(&rbuf, &r_len, &o_len, 1,

                                             exec_format2, 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, NULL);   /* Not interested in output */

        netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, 

                               NETSNMP_DS_LIB_QUICK_PRINT, oldquick);

        if (pdu->command == SNMP_MSG_TRAP)

            snmp_free_pdu(v2_pdu);

        free(rbuf);

    }

    return NETSNMPTRAPD_HANDLER_OK;

#endif /* !def USING_UTILITIES_EXECUTE_MODULE */

}

/*

 *  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 );