path: root/agent/mibgroup/disman/event/mteTriggerConf.c

/*
 * DisMan Event MIB:
 *     Implementation of the trigger table configure handling
 */

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/agent_callbacks.h>
#include "utilities/iquery.h"
#include "disman/event/mteObjects.h"
#include "disman/event/mteTrigger.h"
#include "disman/event/mteTriggerConf.h"

#include <ctype.h>


/** Initializes the mteTriggerConf module */
void
init_mteTriggerConf(void)
{
    init_trigger_table_data();

    /*
     * Register config handler for user-level (fixed) triggers ...
     */
    snmpd_register_config_handler("monitor",
                                   parse_mteMonitor,  NULL,
                                  "triggername [-I] [-i OID | -o OID]* [-e event] expression ");
    snmpd_register_config_handler("defaultMonitors",
                                   parse_default_mteMonitors, NULL, "yes|no");
    snmpd_register_config_handler("linkUpDownNotifications",
                                   parse_linkUpDown_traps,    NULL, "yes|no");

    /*
     * ... for persistent storage of various event table entries ...
     */
    snmpd_register_config_handler("_mteTTable",
                                   parse_mteTTable,   NULL, NULL);
    snmpd_register_config_handler("_mteTDTable",
                                   parse_mteTDTable,  NULL, NULL);
    snmpd_register_config_handler("_mteTExTable",
                                   parse_mteTExTable, NULL, NULL);
    snmpd_register_config_handler("_mteTBlTable",
                                   parse_mteTBlTable, NULL, NULL);
    snmpd_register_config_handler("_mteTThTable",
                                   parse_mteTThTable, NULL, NULL);

    /*
     * ... and backwards compatability with the previous implementation.
     */
    snmpd_register_config_handler("mteTriggerTable",
                                   parse_mteTriggerTable, NULL, NULL);

    /*
     * Register to save (non-fixed) entries when the agent shuts down
     */
    snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
                           store_mteTTable, NULL);
    snmp_register_callback(SNMP_CALLBACK_APPLICATION,
                           SNMPD_CALLBACK_PRE_UPDATE_CONFIG,
                           clear_mteTTable, NULL);
}

/* ==============================
 *
 *       utility routines
 *
 * ============================== */

    /*
     * Find or create the specified trigger entry
     */
struct mteTrigger *
_find_mteTrigger_entry( char *owner, char *tname )
{
    netsnmp_variable_list owner_var, tname_var;
    netsnmp_tdata_row *row;

        /*
         * If there's already an existing entry,
         *   then use that...
         */
    memset(&owner_var, 0, sizeof(netsnmp_variable_list));
    memset(&tname_var, 0, sizeof(netsnmp_variable_list));
    snmp_set_var_typed_value(&owner_var, ASN_OCTET_STR, owner, strlen(owner));
    snmp_set_var_typed_value(&tname_var, ASN_PRIV_IMPLIED_OCTET_STR,
                                                        tname, strlen(tname));
    owner_var.next_variable = &tname_var;
    row = netsnmp_tdata_row_get_byidx( trigger_table_data, &owner_var );
        /*
         * ... otherwise, create a new one
         */
    if (!row)
        row = mteTrigger_createEntry( owner, tname, 0 );
    if (!row)
        return NULL;
    
    /* return (struct mteTrigger *)netsnmp_tdata_row_entry( row ); */
    return (struct mteTrigger *)row->data;
}

struct mteTrigger *
_find_typed_mteTrigger_entry( char *owner, char *tname, int type )
{
    struct mteTrigger *entry = _find_mteTrigger_entry( owner, tname );
    if (!entry)
        return NULL;

    /*
     *  If this is an existing (i.e. valid) entry of the
     *    same type, then throw an error and discard it.
     *  But allow combined Existence/Boolean/Threshold trigger.
     */
    if ( entry &&
        (entry->flags & MTE_TRIGGER_FLAG_VALID) &&
        (entry->mteTriggerTest & type )) {
        config_perror("duplicate trigger name");
        return NULL;
    }
    return entry;
}


/* ================================================
 *
 *  Handlers for user-configured (static) triggers
 *
 * ================================================ */

int
_mteTrigger_callback_enable( int   majorID,    int   minorID,
                             void *serverargs, void *clientarg)
{
    struct mteTrigger *entry = (struct mteTrigger *)clientarg;
    mteTrigger_enable( entry );

    return 0;
}


void
parse_mteMonitor(const char *token, char *line)
{
    char   buf[  SPRINT_MAX_LEN];
    char   tname[MTE_STR1_LEN+1];
    char  *cp;
    long   test = 0;

    char   ename[MTE_STR1_LEN+1];
    long   flags = MTE_TRIGGER_FLAG_ENABLED |
                   MTE_TRIGGER_FLAG_ACTIVE  |
                   MTE_TRIGGER_FLAG_FIXED   |
                   MTE_TRIGGER_FLAG_VWILD   |
                   MTE_TRIGGER_FLAG_SYSUPT  |
                   MTE_TRIGGER_FLAG_VALID;
    long   idx     = 0;
    long   startup = 1;    /* ??? or 0 */
    long   repeat  = 600;
    netsnmp_session *sess = NULL;

    int    seen_name = 0;
    char   oid_name_buf[SPRINT_MAX_LEN];
    oid    name_buf[MAX_OID_LEN];
    size_t name_buf_len;
    long   op    = 0;
    long   value = 0;

    struct mteObject  *object;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing disman monitor config (%s)\n", line));

    /*
     * Before parsing the configuration fully, first
     * skim through the config line in order to:
     *   a) locate the name for the trigger, and
     *   b) identify the type of trigger test
     *
     * This information will be used both for creating the trigger
     *  entry, and registering any additional payload objects.
     */
    memset( buf,   0, sizeof(buf));
    memset( tname, 0, sizeof(tname));
    memset( ename, 0, sizeof(ename));
    for (cp = copy_nword(line, buf, SPRINT_MAX_LEN);
         ;
         cp = copy_nword(cp,   buf, SPRINT_MAX_LEN)) {

        if ( buf[0] == '-' ) {
            switch (buf[1]) {
            case 't':
                /* No longer necessary */
                break;
            case 'd':
            case 'e':
            case 'o':
            case 'r':
            case 'u':
                /* skip option parameter */
                cp = skip_token( cp );
                break;
            case 'D':
            case 'I':
            case 's':
            case 'S':
                /* flag options */
                break;
            case 'i':
                /*
                 * '-i' can act as a flag or take a parameter.
                 *      Handle either case.
                 */
                if (cp && *cp != '-')
                    cp = skip_token( cp );
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                /* accept negative values */
            case '\0':
                /* and '-' placeholder value */
                break;
            default:
                config_perror("unrecognised option");
                return;
            }
        } else {
            /*
             * Save the first non-option parameter as the trigger name.
             *
             * This name will also be used to register entries in the
             *    mteObjectsTable, so insert a distinguishing prefix.
             * This will ensure combined trigger entries don't clash with
             *    each other, or with a similarly-named notification event.
             */
            if ( !tname[0] ) {
                tname[0] = '_';
                tname[1] = '_';   /* Placeholder */
                memcpy( tname+2, buf, MTE_STR1_LEN-2 );
            } else {
                /*
                 * This marks the beginning of the monitor expression,
                 *   so we don't need to scan any further
                 */
                break;
            }
        }
        if (!cp)
            break;
    }

    /*
     * Now let's examine the expression to determine the type of
     *   monitor being configured.  There are four possible forms:
     *     != OID  (or ! OID)     (existence test)
     *        OID                 (existence test)
     *        OID  op  VALUE      (boolean   test)
     *        OID  MIN MAX        (threshold test)
     */
    if ( *buf == '!' ) {
       /*
        * If the expression starts with '!=' or '!', then
        *  it must be the first style of existence test.
        */
       test = MTE_TRIGGER_EXISTENCE;
    } else {
       /*
        * Otherwise the first token is the OID to be monitored.
        *   Skip it and look at the next token (if any).
        */
        cp = copy_nword(cp,   buf, SPRINT_MAX_LEN);
        if (cp) {
            /*
             * If this is a numeric value, then it'll be the MIN
             *   field of a threshold test (the fourth form)
             * Otherwise it'll be the operation field of a
             *   boolean test (the third form)
             */
            if ( isdigit(buf[0]) || buf[0] == '-' )
                test = MTE_TRIGGER_THRESHOLD;
            else
                test = MTE_TRIGGER_BOOLEAN;
        } else {
            /*
             * If there isn't a "next token", then this
             *   must be the second style of existence test.
             */
            test = MTE_TRIGGER_EXISTENCE;
        }
    }

    /*
     * Use the type of trigger test to update the trigger name buffer
     */
    switch (test) {
    case MTE_TRIGGER_BOOLEAN:
        tname[1] = 'B'; break;
    case MTE_TRIGGER_THRESHOLD:
        tname[1] = 'T'; break;
    case MTE_TRIGGER_EXISTENCE:
        tname[1] = 'X'; break;
    }
    
 
    
    /*
     * Now start parsing again at the beginning of the directive,
     *   extracting the various options...
     */
    for (cp = copy_nword(line, buf, SPRINT_MAX_LEN);
         ;
         cp = copy_nword(cp,   buf, SPRINT_MAX_LEN)) {

        if (buf[0] == '-' ) {
            switch (buf[1]) {
            case 'D':   /* delta sample value */
                flags |= MTE_TRIGGER_FLAG_DELTA;
                break;

            case 'd':   /* discontinuity OID (implies delta sample) */
                flags |= MTE_TRIGGER_FLAG_DELTA;
                if (buf[2] != 'i')
                    flags |= MTE_TRIGGER_FLAG_DWILD;
                memset( oid_name_buf, 0, sizeof(oid_name_buf));
                memset(     name_buf, 0, sizeof(    name_buf));
                name_buf_len = MAX_OID_LEN;
                cp = copy_nword(cp, oid_name_buf, MTE_STR1_LEN);
                if (!snmp_parse_oid(oid_name_buf, name_buf, &name_buf_len)) {
                    snmp_log(LOG_ERR, "discontinuity OID: %s\n", oid_name_buf);
                    config_perror("unknown discontinuity OID");
                    mteObjects_removeEntries( "snmpd.conf", tname );
                    return;
                }
                if ( snmp_oid_compare( name_buf, name_buf_len,
                                       _sysUpTime_instance,
                                       _sysUpTime_inst_len) != 0 )
                    flags &= ~MTE_TRIGGER_FLAG_SYSUPT;
                break;
    
            case 'e':   /*  event */
                cp     = copy_nword(cp, ename, MTE_STR1_LEN);
                break;
    
            case 'I':   /* value instance */
                flags &= ~MTE_TRIGGER_FLAG_VWILD;
                break;
    
                        /*
                         * "instance" flag:
                         *     either non-wildcarded mteTriggerValueID
                         *       (backwards compatability - see '-I')
                         *     or exact payload OID
                         *       (c.f. notificationEvent config)
                         */
            case 'i':
                if ( *cp == '-' ) {
                    /* Backwards compatibility - now '-I' */
                    flags &= ~MTE_TRIGGER_FLAG_VWILD;
                    continue;
                }
                idx++;
                cp     = copy_nword(cp, buf, SPRINT_MAX_LEN);
                object = mteObjects_addOID( "snmpd.conf", tname, idx, buf, 0 );
                if (!object) {
                    snmp_log(LOG_ERR, "Unknown payload OID: %s\n", buf);
                    config_perror("Unknown payload OID");
                    mteObjects_removeEntries( "snmpd.conf", tname );
                } else
                    idx = object->mteOIndex;
                break;
    
            case 'o':   /*  object  */
                idx++;
                cp     = copy_nword(cp, buf, SPRINT_MAX_LEN);
                object = mteObjects_addOID( "snmpd.conf", tname, idx, buf, 1 );
                if (!object) {
                    snmp_log(LOG_ERR, "Unknown payload OID: %s\n", buf);
                    config_perror("Unknown payload OID");
                    mteObjects_removeEntries( "snmpd.conf", tname );
                } else
                    idx = object->mteOIndex;
                break;
    
            case 'r':   /*  repeat frequency */
                cp     = copy_nword(cp, buf, SPRINT_MAX_LEN);
                repeat = strtoul(buf, NULL, 0);
                break;
    
            case 'S':   /* disable startup tests */
                startup = 0;
                break;

            case 's':   /* enable startup tests (default?) */
                startup = 1;
                break;

            case 't':   /* threshold test - already handled */
                break;
    
            case 'u':   /*  user */
                cp     = copy_nword(cp, buf, SPRINT_MAX_LEN);
                sess   = netsnmp_iquery_user_session(buf);
                if (NULL == sess) {
                    snmp_log(LOG_ERR, "user name %s not found\n", buf);
                    config_perror("Unknown user name\n");
                    mteObjects_removeEntries( "snmpd.conf", tname );
                    return;
                }
                break;
            }
        } else {
            /*
             * Skip the first non-option token - the trigger
             *  name (which has already been processed earlier).
             */
            if ( !seen_name ) {
                seen_name = 1;
            } else {
                /*
                 * But the next non-option token encountered will
                 *  mark the start of the expression to be monitored.
                 *
                 * There are three possible expression formats:
                 *      [op] OID               (existence tests)
                 *      OID op value           (boolean tests)
                 *      OID val val [val val]  (threshold tests)
                 * 
                 * Extract the OID, operation and (first) value.
                 */
                switch ( test ) {
                case MTE_TRIGGER_EXISTENCE:
                    /*
                     * Identify the existence operator (if any)...
                     */
                    op = MTE_EXIST_PRESENT;
                    if (buf[0] == '!') {
                       if (buf[1] == '=') {
                           op = MTE_EXIST_CHANGED;
                       } else {
                           op = MTE_EXIST_ABSENT;
                       }
                       cp = copy_nword(cp, buf, SPRINT_MAX_LEN);
                    }
                    /*
                     * ... then extract the monitored OID.
                     *     (ignoring anything that remains)
                     */
                    memcpy(oid_name_buf, buf, SPRINT_MAX_LEN);
                    cp = NULL;  /* To terminate the processing loop */
                    DEBUGMSGTL(("disman:event:conf", "%s: Exist (%s, %d)\n",
                                                     tname, oid_name_buf, op));
                    break;
    
                case MTE_TRIGGER_BOOLEAN:
                    /*
                     * Extract the monitored OID, and 
                     *   identify the boolean operator ...
                     */
                    memcpy(oid_name_buf, buf, SPRINT_MAX_LEN);
                    cp = copy_nword(cp, buf, SPRINT_MAX_LEN);
                    if (buf[0] == '!') {
                       op = MTE_BOOL_UNEQUAL;
                    } else if (buf[0] == '=') {
                       op = MTE_BOOL_EQUAL;
                    } else if (buf[0] == '<') {
                       if (buf[1] == '=') {
                           op = MTE_BOOL_LESSEQUAL;
                       } else {
                           op = MTE_BOOL_LESS;
                       }
                    } else if (buf[0] == '>') {
                       if (buf[1] == '=') {
                           op = MTE_BOOL_GREATEREQUAL;
                       } else {
                           op = MTE_BOOL_GREATER;
                       }
                    }
                    /*
                     * ... then extract the comparison value.
                     *     (ignoring anything that remains)
                     */
                    cp    = copy_nword(cp, buf, SPRINT_MAX_LEN);
                    value = strtol(buf, NULL, 0);
                    cp = NULL;  /* To terminate the processing loop */
                    DEBUGMSGTL(("disman:event:conf", "%s: Bool (%s, %d, %d)\n",
                                              tname, oid_name_buf, op, value));
                    break;
    
                case MTE_TRIGGER_THRESHOLD:
                    /*
                     * Extract the monitored OID, and 
                     *   the first comparison value...
                     */
                    memcpy(oid_name_buf, buf, SPRINT_MAX_LEN);
                    memset(         buf,   0, SPRINT_MAX_LEN);
                    cp  = copy_nword(cp, buf, SPRINT_MAX_LEN);
                        value = strtol(buf, NULL, 0);
    
                    /*
                     * ... then save the rest of the line for later.
                     */
                    memset( buf, 0,  strlen(buf));
                    memcpy( buf, cp, strlen(cp));
                    cp = NULL;  /* To terminate the processing loop */
                    DEBUGMSGTL(("disman:event:conf", "%s: Thresh (%s, %d, %s)\n",
                                              tname, oid_name_buf, value, buf));
                    break;
                }
            }
        }
        if (!cp)
            break;
    }

    if (NULL == sess) {
        sess = netsnmp_query_get_default_session();
        if (NULL == sess) {
            config_perror
                ("You must specify a default user name using the agentSecName token\n");
            mteObjects_removeEntries( "snmpd.conf", tname );
            return;
        }
    }

    /*
     *  ... and then create the new trigger entry...
     */
    entry = _find_typed_mteTrigger_entry( "snmpd.conf", tname+2, test );
    if (!entry) {
        /* mteObjects_removeEntries( "snmpd.conf", tname ); */
        return;
    }

    /*
     *  ... populate the type-independent fields...
     *     (setting the delta discontinuity OID first)
     */
    if ( (flags & MTE_TRIGGER_FLAG_DELTA) &&
        !(flags & MTE_TRIGGER_FLAG_SYSUPT)) {
        memset( entry->mteDeltaDiscontID, 0, sizeof(entry->mteDeltaDiscontID));
        memcpy( entry->mteDeltaDiscontID, name_buf, name_buf_len*sizeof(oid));
        entry->mteDeltaDiscontID_len = name_buf_len;
    }
    name_buf_len = MAX_OID_LEN;
    if (!snmp_parse_oid(oid_name_buf, name_buf, &name_buf_len)) {
        snmp_log(LOG_ERR, "trigger OID: %s\n", oid_name_buf);
        config_perror("unknown monitor OID");
        mteObjects_removeEntries( "snmpd.conf", tname );
        return;
    }
    entry->session               = sess;
    entry->flags                |= flags;
    entry->mteTriggerTest       |= test;
    entry->mteTriggerFrequency   = repeat;
    entry->mteTriggerValueID_len = name_buf_len;
    memcpy(entry->mteTriggerValueID, name_buf, name_buf_len*sizeof(oid));

    /*
     * ... and the relevant test-specific fields.
     */
    switch (test) {
    case MTE_TRIGGER_EXISTENCE:
        entry->mteTExTest = op;
        if (op != MTE_EXIST_CHANGED && startup)
            entry->mteTExStartup = op;
        if ( idx > 0 ) {
            /*
             * Refer to the objects for this trigger (if any)...
             */
            memset(entry->mteTExObjOwner, 0,     MTE_STR1_LEN+1);
            memcpy(entry->mteTExObjOwner, "snmpd.conf",      10);
            memcpy(entry->mteTExObjects,  tname, MTE_STR1_LEN+1);
        }
        if ( ename[0] ) {
            /*
             * ... and the specified event...
             */
            memset(entry->mteTExEvOwner,  0,     MTE_STR1_LEN+1);
            if ( ename[0] == '_' )
                memcpy(entry->mteTExEvOwner,  "_snmpd",       6);
            else
                memcpy(entry->mteTExEvOwner,  "snmpd.conf",  10);
            memcpy(entry->mteTExEvent,    ename, MTE_STR1_LEN+1);
        } else {
            /*
             * ... or the hardcoded default event.
             */
            memset(entry->mteTExEvOwner,  0,     MTE_STR1_LEN+1);
            memset(entry->mteTExEvent,    0,     MTE_STR1_LEN+1);
            memcpy(entry->mteTExEvOwner,  "_snmpd",           6);
            memcpy(entry->mteTExEvent,    "_mteTriggerFired", 16);
        }
        break;
    case MTE_TRIGGER_BOOLEAN:
        entry->mteTBoolComparison = op;
        entry->mteTBoolValue      = value;
        if (!startup)
            entry->flags &= ~MTE_TRIGGER_FLAG_BSTART;
        if ( idx > 0 ) {
            /*
             * Refer to the objects for this trigger (if any)...
             */
            memset(entry->mteTBoolObjOwner, 0,     MTE_STR1_LEN+1);
            memcpy(entry->mteTBoolObjOwner, "snmpd.conf",      10);
            memcpy(entry->mteTBoolObjects,  tname, MTE_STR1_LEN+1);
        }
        if ( ename[0] ) {
            /*
             * ... and the specified event...
             */
            memset(entry->mteTBoolEvOwner,  0,     MTE_STR1_LEN+1);
            if ( ename[0] == '_' )
                memcpy(entry->mteTBoolEvOwner,  "_snmpd",       6);
            else
                memcpy(entry->mteTBoolEvOwner,  "snmpd.conf",  10);
            memcpy(entry->mteTBoolEvent,    ename, MTE_STR1_LEN+1);
        } else {
            /*
             * ... or the hardcoded default event.
             */
            memset(entry->mteTBoolEvOwner,  0,     MTE_STR1_LEN+1);
            memset(entry->mteTBoolEvent,    0,     MTE_STR1_LEN+1);
            memcpy(entry->mteTBoolEvOwner,  "_snmpd",           6);
            memcpy(entry->mteTBoolEvent,    "_mteTriggerFired", 16);
        }
        break;
    case MTE_TRIGGER_THRESHOLD:
            entry->mteTThFallValue  = value;
            value = strtol(buf, NULL, 0);
            entry->mteTThRiseValue  = value;
            if (!startup)
                entry->mteTThStartup = 0;
            if ( idx > 0 ) {
                /*
                 * Refer to the objects for this trigger (if any)...
                 */
                memset(entry->mteTThObjOwner,   0,     MTE_STR1_LEN+1);
                memcpy(entry->mteTThObjOwner,   "snmpd.conf",      10);
                memcpy(entry->mteTThObjects,    tname, MTE_STR1_LEN+1);
            }
            if ( ename[0] ) {
                /*
                 * ... and the specified event...
                 *  (using the same event for all triggers)
                 */
                memset(entry->mteTThRiseOwner,  0,     MTE_STR1_LEN+1);
                if ( ename[0] == '_' )
                    memcpy(entry->mteTThRiseOwner,  "_snmpd",       6);
                else
                    memcpy(entry->mteTThRiseOwner,  "snmpd.conf",  10);
                memcpy(entry->mteTThRiseEvent,  ename, MTE_STR1_LEN+1);
                memset(entry->mteTThFallOwner,  0,     MTE_STR1_LEN+1);
                if ( ename[0] == '_' )
                    memcpy(entry->mteTThFallOwner,  "_snmpd",       6);
                else
                    memcpy(entry->mteTThFallOwner,  "snmpd.conf",  10);
                memcpy(entry->mteTThFallEvent,  ename, MTE_STR1_LEN+1);
            } else {
                /*
                 * ... or the hardcoded default events.
                 */
                memset(entry->mteTThRiseOwner,  0,     MTE_STR1_LEN+1);
                memset(entry->mteTThFallOwner,  0,     MTE_STR1_LEN+1);
                memset(entry->mteTThRiseEvent,  0,     MTE_STR1_LEN+1);
                memset(entry->mteTThFallEvent,  0,     MTE_STR1_LEN+1);
                memcpy(entry->mteTThRiseOwner,  "_snmpd",           6);
                memcpy(entry->mteTThFallOwner,  "_snmpd",           6);
                memcpy(entry->mteTThRiseEvent,  "_mteTriggerRising", 17);
                memcpy(entry->mteTThFallEvent,  "_mteTriggerFalling", 18);
            }
            cp = skip_token(buf);   /* skip riseThreshold value */

        /*
         * Parse and set (optional) Delta thresholds & events
         */
        if ( cp && *cp != '\0' ) {
            if (entry->flags & MTE_TRIGGER_FLAG_DELTA) {
                config_perror("Delta-threshold on delta-samples not supported");
                mteObjects_removeEntries( "snmpd.conf", tname );
                return;
            }
            value = strtol(cp, NULL, 0);
            entry->mteTThDFallValue  = value;
            cp = skip_token(cp);
            value = strtol(cp, NULL, 0);
            entry->mteTThDRiseValue  = value;
            /*
             * Set the events in the same way as before
             */
            if ( ename[0] ) {
                memset(entry->mteTThDRiseOwner,  0,     MTE_STR1_LEN+1);
                if ( ename[0] == '_' )
                    memcpy(entry->mteTThDRiseOwner,  "_snmpd",       6);
                else
                    memcpy(entry->mteTThDRiseOwner,  "snmpd.conf",  10);
                memcpy(entry->mteTThDRiseEvent,  ename, MTE_STR1_LEN+1);
                memset(entry->mteTThDFallOwner,  0,     MTE_STR1_LEN+1);
                if ( ename[0] == '_' )
                    memcpy(entry->mteTThDFallOwner,  "_snmpd",       6);
                else
                    memcpy(entry->mteTThDFallOwner,  "snmpd.conf",  10);
                memcpy(entry->mteTThDFallEvent,  ename, MTE_STR1_LEN+1);
            } else {
                memset(entry->mteTThDRiseOwner,  0,     MTE_STR1_LEN+1);
                memset(entry->mteTThDFallOwner,  0,     MTE_STR1_LEN+1);
                memset(entry->mteTThDRiseEvent,  0,     MTE_STR1_LEN+1);
                memset(entry->mteTThDFallEvent,  0,     MTE_STR1_LEN+1);
                memcpy(entry->mteTThDRiseOwner,  "_snmpd",           6);
                memcpy(entry->mteTThDFallOwner,  "_snmpd",           6);
                memcpy(entry->mteTThDRiseEvent,  "_mteTriggerRising", 17);
                memcpy(entry->mteTThDFallEvent,  "_mteTriggerFalling", 18);
            }
        }
 
        break;
    }
    snmp_register_callback(SNMP_CALLBACK_LIBRARY, 
                           SNMP_CALLBACK_POST_READ_CONFIG,
                           _mteTrigger_callback_enable, entry );
    return;
}

void
parse_linkUpDown_traps(const char *token, char *line)
{
    /*
     * XXX - This isn't strictly correct according to the
     *       definitions in IF-MIB, but will do for now.
     */
    if (strncmp( line, "yes", 3) == 0) {
        DEBUGMSGTL(("disman:event:conf", "Registering linkUpDown traps\n"));

        /* ifOperStatus */
        parse_mteMonitor("monitor",
            "-r 60 -S -e _linkUp   \"linkUp\"   .1.3.6.1.2.1.2.2.1.8 != 2");
        parse_mteMonitor("monitor",
            "-r 60 -S -e _linkDown \"linkDown\" .1.3.6.1.2.1.2.2.1.8 == 2");
    }
}


void
parse_default_mteMonitors(const char *token, char *line)
{
    if (strncmp( line, "yes", 3) == 0) {
        DEBUGMSGTL(("disman:event:conf", "Registering default monitors\n"));

        parse_mteMonitor("monitor",
            "-o prNames -o prErrMessage   \"process table\" prErrorFlag  != 0");
        parse_mteMonitor("monitor",
            "-o memErrorName -o memSwapErrorMsg \"memory\"  memSwapError != 0");
        parse_mteMonitor("monitor",
            "-o extNames -o extOutput     \"extTable\"      extResult    != 0");
        parse_mteMonitor("monitor",
            "-o dskPath -o dskErrorMsg    \"dskTable\"      dskErrorFlag != 0");
        parse_mteMonitor("monitor",
            "-o laNames -o laErrMessage   \"laTable\"       laErrorFlag  != 0");
        parse_mteMonitor("monitor",
            "-o fileName -o fileErrorMsg  \"fileTable\"    fileErrorFlag != 0");
        parse_mteMonitor("monitor",
            "-o snmperrErrMessage         \"snmperrs\"  snmperrErrorFlag != 0");
    }
    return;
}

/* ================================================
 *
 *  Handlers for loading persistent trigger entries
 *
 * ================================================ */



/* 
 *  Entries for the main mteTriggerTable
 */

char *
_parse_mteTCols( char *line, struct mteTrigger *entry, int bcomp )
{
    void  *vp;
    size_t tmp;
    size_t len;

    len  = MTE_STR2_LEN; vp = entry->mteTriggerComment;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    if ( bcomp ) {
        /*
         * The newer style of config directive skips the
         *   mteTriggerTest and mteTriggerSampleType values,
         *   as these are set implicitly from the relevant
         *   config directives.
         * Backwards compatability with the previous (combined) 
         *   style reads these in explicitly.
         */
        len  = 1;
        vp   = &entry->mteTriggerTest;
        line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        if (tmp == 2)
            entry->flags |= MTE_TRIGGER_FLAG_DELTA;
    }
    vp   = entry->mteTriggerValueID;
    entry->mteTriggerValueID_len = MAX_OID_LEN;
    line = read_config_read_data(ASN_OBJECT_ID, line, &vp,
                                &entry->mteTriggerValueID_len);
    if (bcomp) {
        /*
         * The newer style combines the various boolean values
         *   into a single field (which comes later).
         * Backwards compatability means reading these individually. 
         */
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        if (tmp == TV_TRUE)
            entry->flags |= MTE_TRIGGER_FLAG_VWILD;
    }
    len  = MTE_STR2_LEN; vp = entry->mteTriggerTarget;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR2_LEN; vp = entry->mteTriggerContext;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    if (bcomp) {
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        if (tmp == TV_TRUE)
            entry->flags |= MTE_TRIGGER_FLAG_CWILD;
    }

    line = read_config_read_data(ASN_UNSIGNED,  line,
                                &entry->mteTriggerFrequency, NULL);

    len  = MTE_STR1_LEN; vp = entry->mteTriggerOOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN; vp = entry->mteTriggerObjects;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);

    /*
     * Assorted boolean flag values, combined into a single field
     */
    if (bcomp) {
        /*
         * Backwards compatability stores the mteTriggerEnabled
         *   and mteTriggerEntryStatus values separately...
         */
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        if (tmp == TV_TRUE)
            entry->flags |= MTE_TRIGGER_FLAG_ENABLED;
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        if (tmp == RS_ACTIVE)
            entry->flags |= MTE_TRIGGER_FLAG_ACTIVE;
    } else {
        /*
         * ... while the newer style combines all the assorted
         *       boolean values into this single field.
         */
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        entry->flags |= ( tmp &
            (MTE_TRIGGER_FLAG_VWILD  |MTE_TRIGGER_FLAG_CWILD|
             MTE_TRIGGER_FLAG_ENABLED|MTE_TRIGGER_FLAG_ACTIVE));
    }

    return line;
}

void
parse_mteTTable(const char *token, char *line)
{
    char   owner[MTE_STR1_LEN+1];
    char   tname[MTE_STR1_LEN+1];
    void  *vp;
    size_t len;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteTriggerTable config...\n"));

    /*
     * Read in the index information for this entry
     *  and create a (non-fixed) data structure for it.
     */
    memset( owner, 0, sizeof(owner));
    memset( tname, 0, sizeof(tname));
    len   = MTE_STR1_LEN; vp = owner;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len   = MTE_STR1_LEN; vp = tname;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    entry = _find_mteTrigger_entry( owner, tname );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, tname));
    
    /*
     * Read in the accessible (trigger-independent) column values.
     */
    line = _parse_mteTCols( line, entry, 0 );
    /*
     * XXX - Will need to read in the 'iquery' access information
     */
    entry->flags |= MTE_TRIGGER_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));
}


/* 
 *  Entries from the mteTriggerDeltaTable
 */

char *
_parse_mteTDCols( char *line, struct mteTrigger *entry, int bcomp )
{
    void  *vp;
    size_t tmp;

    entry->mteDeltaDiscontID_len = MAX_OID_LEN;
    vp   = entry->mteDeltaDiscontID;
    line = read_config_read_data(ASN_OBJECT_ID, line, &vp,
                                &entry->mteDeltaDiscontID_len);
    line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
    if (bcomp) {
        if ( tmp == TV_TRUE )
            entry->flags |= MTE_TRIGGER_FLAG_DWILD;
    } else {
        if ( tmp & MTE_TRIGGER_FLAG_DWILD )
            entry->flags |= MTE_TRIGGER_FLAG_DWILD;
    }
    line = read_config_read_data(ASN_UNSIGNED,  line,
                                &entry->mteDeltaDiscontIDType, NULL);

    return line;
}

void
parse_mteTDTable(const char *token, char *line)
{
    char   owner[MTE_STR1_LEN+1];
    char   tname[MTE_STR1_LEN+1];
    void  *vp;
    size_t len;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteTriggerDeltaTable config... "));

    /*
     * Read in the index information for this entry
     *  and create a (non-fixed) data structure for it.
     */
    memset( owner, 0, sizeof(owner));
    memset( tname, 0, sizeof(tname));
    len   = MTE_STR1_LEN; vp = owner;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len   = MTE_STR1_LEN; vp = tname;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    entry = _find_mteTrigger_entry( owner, tname );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, tname));
    
    /*
     * Read in the accessible column values.
     */
    line = _parse_mteTDCols( line, entry, 0 );

    entry->flags |= (MTE_TRIGGER_FLAG_DELTA|
                     MTE_TRIGGER_FLAG_VALID);

    DEBUGMSG(("disman:event:conf", "\n"));
}


/* 
 *  Entries from the mteTriggerExistenceTable
 */

char *
_parse_mteTExCols( char *line, struct mteTrigger *entry, int bcomp )
{
    void  *vp;
    size_t tmp;
    size_t len;

    if (bcomp) {
        len  = 1;
        vp   = &entry->mteTExTest;
        line = read_config_read_data(ASN_OCTET_STR,  line, &vp, &len);
        len  = 1;
        vp   = &entry->mteTExStartup;
        line = read_config_read_data(ASN_OCTET_STR,  line, &vp, &len);
    } else {
        line  = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        entry->mteTExStartup = ( tmp & 0xff ); tmp >>= 8;
        entry->mteTExTest    = ( tmp & 0xff );
    }

    len  = MTE_STR1_LEN; vp = entry->mteTExObjOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len  = MTE_STR1_LEN; vp = entry->mteTExObjects;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);

    len  = MTE_STR1_LEN; vp = entry->mteTExEvOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len  = MTE_STR1_LEN; vp = entry->mteTExEvent;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);

    return line;
}

void
parse_mteTExTable(const char *token, char *line)
{
    char   owner[MTE_STR1_LEN+1];
    char   tname[MTE_STR1_LEN+1];
    void  *vp;
    size_t len;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteTriggerExistenceTable config...  "));

    /*
     * Read in the index information for this entry
     *  and create a (non-fixed) data structure for it.
     */
    memset( owner, 0, sizeof(owner));
    memset( tname, 0, sizeof(tname));
    len   = MTE_STR1_LEN; vp = owner;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len   = MTE_STR1_LEN; vp = tname;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    entry = _find_mteTrigger_entry( owner, tname );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, tname));
    
    /*
     * Read in the accessible column values.
     *  (Note that the first two are combined into a single field)
     */
    line = _parse_mteTExCols( line, entry, 0 );

    entry->mteTriggerTest |= MTE_TRIGGER_EXISTENCE;
    entry->flags          |= MTE_TRIGGER_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));
}


/* 
 *  Entries from the mteTriggerBooleanTable
 */

char *
_parse_mteTBlCols( char *line, struct mteTrigger *entry, int bcomp )
{
    void  *vp;
    size_t tmp;
    size_t len;

    if (bcomp) {
        line = read_config_read_data(ASN_UNSIGNED,  line,
                                    &entry->mteTBoolComparison, NULL);
        line = read_config_read_data(ASN_INTEGER,   line,
                                    &entry->mteTBoolValue, NULL);
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        if (tmp == TV_TRUE)
            entry->flags |= MTE_TRIGGER_FLAG_BSTART;
    } else {
        line = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);
        entry->mteTBoolComparison = ( tmp & 0x0f );
        entry->flags             |= ( tmp & MTE_TRIGGER_FLAG_BSTART );
        line = read_config_read_data(ASN_INTEGER,   line,
                                    &entry->mteTBoolValue, NULL);
    }


    len  = MTE_STR1_LEN; vp = entry->mteTBoolObjOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len  = MTE_STR1_LEN; vp = entry->mteTBoolObjects;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);

    len  = MTE_STR1_LEN; vp = entry->mteTBoolEvOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len  = MTE_STR1_LEN; vp = entry->mteTBoolEvent;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);

    return line;
}

void
parse_mteTBlTable(const char *token, char *line)
{
    char   owner[MTE_STR1_LEN+1];
    char   tname[MTE_STR1_LEN+1];
    void  *vp;
    size_t len;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteTriggerBooleanTable config...  "));

    /*
     * Read in the index information for this entry
     *  and create a (non-fixed) data structure for it.
     */
    memset( owner, 0, sizeof(owner));
    memset( tname, 0, sizeof(tname));
    len   = MTE_STR1_LEN; vp = owner;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len   = MTE_STR1_LEN; vp = tname;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    entry = _find_mteTrigger_entry( owner, tname );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, tname));
    
    /*
     * Read in the accessible column values.
     *  (Note that the first & third are combined into a single field)
     */
    line = _parse_mteTBlCols( line, entry, 0 );

    entry->mteTriggerTest |= MTE_TRIGGER_BOOLEAN;
    entry->flags          |= MTE_TRIGGER_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));
}


/* 
 *  Entries from the mteTriggerThresholdTable
 */

char *
_parse_mteTThCols( char *line, struct mteTrigger *entry, int bcomp )
{
    void  *vp;
    size_t len;

    line = read_config_read_data(ASN_UNSIGNED,  line,
                                &entry->mteTThStartup,    NULL);
    line = read_config_read_data(ASN_INTEGER,   line,
                                &entry->mteTThRiseValue,  NULL);
    line = read_config_read_data(ASN_INTEGER,   line,
                                &entry->mteTThFallValue,  NULL);
    line = read_config_read_data(ASN_INTEGER,   line,
                                &entry->mteTThDRiseValue, NULL);
    line = read_config_read_data(ASN_INTEGER,   line,
                                &entry->mteTThDFallValue, NULL);

    len  = MTE_STR1_LEN;   vp = entry->mteTThObjOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThObjects;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);

    len  = MTE_STR1_LEN;   vp = entry->mteTThRiseOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThRiseEvent;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThFallOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThFallEvent;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);

    len  = MTE_STR1_LEN;   vp = entry->mteTThDRiseOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThDRiseEvent;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThDFallOwner;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);
    len  = MTE_STR1_LEN;   vp = entry->mteTThDFallEvent;
    line = read_config_read_data(ASN_OCTET_STR, line, &vp, &len);

    return line;
}

void
parse_mteTThTable(const char *token, char *line)
{
    char   owner[MTE_STR1_LEN+1];
    char   tname[MTE_STR1_LEN+1];
    void  *vp;
    size_t len;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteTriggerThresholdTable config...  "));

    /*
     * Read in the index information for this entry
     *  and create a (non-fixed) data structure for it.
     */
    memset( owner, 0, sizeof(owner));
    memset( tname, 0, sizeof(tname));
    len   = MTE_STR1_LEN; vp = owner;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len   = MTE_STR1_LEN; vp = tname;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    entry = _find_mteTrigger_entry( owner, tname );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, tname));
    
    /*
     * Read in the accessible column values.
     */
    line = _parse_mteTThCols( line, entry, 0 );

    entry->mteTriggerTest |= MTE_TRIGGER_THRESHOLD;
    entry->flags          |= MTE_TRIGGER_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));
}


/* 
 *  Backwards Compatability with the previous implementation
 */

void
parse_mteTriggerTable(const char *token, char *line)
{
    char   owner[MTE_STR1_LEN+1];
    char   tname[MTE_STR1_LEN+1];
    void  *vp;
    size_t len;
    struct mteTrigger *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing previous mteTriggerTable config...  "));

    /*
     * Read in the index information for this entry
     *  and create a (non-fixed) data structure for it.
     */
    memset( owner, 0, sizeof(owner));
    memset( tname, 0, sizeof(tname));
    len   = MTE_STR1_LEN; vp = owner;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    len   = MTE_STR1_LEN; vp = tname;
    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len);
    entry = _find_mteTrigger_entry( owner, tname );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, tname));
    
    /*
     * Read in the accessible column values for each table in turn...
     *   (similar, though not identical to the newer style).
     */
    line = _parse_mteTCols(   line, entry, 1 );
    line = _parse_mteTDCols(  line, entry, 1 );
    line = _parse_mteTExCols( line, entry, 1 );
    line = _parse_mteTBlCols( line, entry, 1 );
    line = _parse_mteTThCols( line, entry, 1 );

    /*
     * ... and then read in the "local internal variables"
     *   XXX - TODO
     */
    entry->flags          |= MTE_TRIGGER_FLAG_VALID;

    /* XXX - mte_enable_trigger();  ??? */
    DEBUGMSG(("disman:event:conf", "\n"));
}

/* ===============================================
 *
 *  Handler for storing persistent trigger entries
 *
 * =============================================== */

int
store_mteTTable(int majorID, int minorID, void *serverarg, void *clientarg)
{
    char            line[SNMP_MAXBUF];
    char           *cptr;
    void           *vp;
    size_t          tint;
    netsnmp_tdata_row *row;
    struct mteTrigger  *entry;


    DEBUGMSGTL(("disman:event:conf", "Storing mteTriggerTable config:\n"));

    for (row = netsnmp_tdata_row_first( trigger_table_data );
         row;
         row = netsnmp_tdata_row_next( trigger_table_data, row )) {

        /*
         * Skip entries that were set up via static config directives
         */
        entry = (struct mteTrigger *)netsnmp_tdata_row_entry( row );
        if ( entry->flags & MTE_TRIGGER_FLAG_FIXED )
            continue;

        DEBUGMSGTL(("disman:event:conf", "  Storing (%s %s)\n",
                         entry->mteOwner, entry->mteTName));

        /*
         * Save the basic mteTriggerTable entry...
         */
        memset(line, 0, sizeof(line));
        strcat(line, "_mteTTable ");
        cptr = line + strlen(line);

        vp   = entry->mteOwner;          tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        vp   = entry->mteTName;          tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        vp   = entry->mteTriggerComment; tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        /*
         * ... (but skip the mteTriggerTest and
         *      assorted boolean flag fields)...
         */
        vp   = entry->mteTriggerValueID;
        tint = entry->mteTriggerValueID_len;
        cptr = read_config_store_data(   ASN_OBJECT_ID, cptr, &vp,  &tint );
        vp   = entry->mteTriggerTarget;  tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        vp   = entry->mteTriggerContext; tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        tint = entry->mteTriggerFrequency;
        cptr = read_config_store_data(   ASN_UNSIGNED,  cptr, &tint, NULL );
        vp   = entry->mteTriggerOOwner;  tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        vp   = entry->mteTriggerObjects; tint = strlen( vp );
        cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
        tint = entry->flags &
                  (MTE_TRIGGER_FLAG_VWILD  |MTE_TRIGGER_FLAG_CWILD|
                   MTE_TRIGGER_FLAG_ENABLED|MTE_TRIGGER_FLAG_ACTIVE);
        cptr = read_config_store_data(   ASN_UNSIGNED,  cptr, &tint, NULL );
        /* XXX - Need to store the 'iquery' access information */
        snmpd_store_config(line);

        /*
         * ... then save the other (relevant) table entries separately,
         *       starting with mteDeltaDiscontinuityTable...
         */
        if ( entry->flags & MTE_TRIGGER_FLAG_DELTA ) {
            memset(line, 0, sizeof(line));
            strcat(line, "_mteTDTable ");
            cptr = line + strlen(line);

            vp   = entry->mteOwner;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTName;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );

            vp   = entry->mteDeltaDiscontID;
            tint = entry->mteDeltaDiscontID_len;
            cptr = read_config_store_data(   ASN_OBJECT_ID, cptr, &vp,  &tint );

            tint = entry->flags & MTE_TRIGGER_FLAG_DWILD;
            cptr = read_config_store_data(   ASN_UNSIGNED,  cptr, &tint, NULL );
            tint = entry->mteDeltaDiscontIDType;
            cptr = read_config_store_data(   ASN_UNSIGNED,  cptr, &tint, NULL );

            snmpd_store_config(line);
        }

        /*
         * ... and the three type-specific trigger tables.
         */
        if ( entry->mteTriggerTest & MTE_TRIGGER_EXISTENCE ) {
            memset(line, 0, sizeof(line));
            strcat(line, "_mteTExTable ");
            cptr = line + strlen(line);

            vp   = entry->mteOwner;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTName;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );

            tint = (entry->mteTExTest    & 0xff) << 8;
            tint|= (entry->mteTExStartup & 0xff);
            cptr = read_config_store_data(   ASN_UNSIGNED,  cptr, &tint, NULL );

            vp   = entry->mteTExObjOwner;  tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTExObjects;   tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            vp   = entry->mteTExEvOwner;   tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTExEvent;     tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            snmpd_store_config(line);
        }
        if ( entry->mteTriggerTest & MTE_TRIGGER_BOOLEAN ) {
            memset(line, 0, sizeof(line));
            strcat(line, "_mteTBlTable ");
            cptr = line + strlen(line);

            vp   = entry->mteOwner;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTName;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );

            tint =  entry->mteTBoolComparison;
            tint |= (entry->flags & MTE_TRIGGER_FLAG_BSTART);
            cptr = read_config_store_data(   ASN_UNSIGNED,  cptr, &tint, NULL );
            tint =  entry->mteTBoolValue;
            cptr = read_config_store_data(   ASN_INTEGER,   cptr, &tint, NULL );

            vp   = entry->mteTBoolObjOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTBoolObjects; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            vp   = entry->mteTBoolEvOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTBoolEvent;   tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            snmpd_store_config(line);
        }
        if ( entry->mteTriggerTest & MTE_TRIGGER_THRESHOLD ) {
            memset(line, 0, sizeof(line));
            strcat(line, "_mteTThTable ");
            cptr = line + strlen(line);

            vp   = entry->mteOwner;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTName;          tint = strlen( vp );
            cptr = read_config_store_data(   ASN_OCTET_STR, cptr, &vp,  &tint );

            cptr = read_config_store_data(ASN_UNSIGNED, cptr,
                                         &entry->mteTThStartup,    NULL );
            cptr = read_config_store_data(ASN_INTEGER,  cptr,
                                         &entry->mteTThRiseValue,  NULL );
            cptr = read_config_store_data(ASN_INTEGER,  cptr,
                                         &entry->mteTThFallValue,  NULL );
            cptr = read_config_store_data(ASN_INTEGER,  cptr,
                                         &entry->mteTThDRiseValue, NULL );
            cptr = read_config_store_data(ASN_INTEGER,  cptr,
                                         &entry->mteTThDFallValue, NULL );

            vp   = entry->mteTThObjOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThObjects; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            vp   = entry->mteTThRiseOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThRiseEvent; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThFallOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThFallEvent; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            vp   = entry->mteTThDRiseOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThDRiseEvent; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThDFallOwner; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );
            vp   = entry->mteTThDFallEvent; tint = strlen( vp );
            cptr = read_config_store_data( ASN_OCTET_STR, cptr, &vp,  &tint );

            snmpd_store_config(line);
        }
    }

    DEBUGMSGTL(("disman:event:conf", "  done.\n"));
    return SNMPERR_SUCCESS;
}

int
clear_mteTTable(int majorID, int minorID, void *serverarg, void *clientarg)
{
    netsnmp_tdata_row *row;
   
    while (( row = netsnmp_tdata_row_first( trigger_table_data ))) {
        struct mteTrigger *entry = (struct mteTrigger *)
            netsnmp_tdata_remove_and_delete_row(trigger_table_data, row);
        if (entry) {
            /* Remove from the callbacks list and disable triggers */
            snmp_unregister_callback( SNMP_CALLBACK_LIBRARY,
                                      SNMP_CALLBACK_POST_READ_CONFIG,
                                      _mteTrigger_callback_enable, entry, 0 ); 
            mteTrigger_disable( entry );
            SNMP_FREE(entry);
        }
    }
    return SNMPERR_SUCCESS;
}