/*
 * This file was generated by mib2c and is intended for use as
 * a mib module for the ucd-snmp snmpd agent. 
 */


/*
 * This should always be included first before anything else 
 */
#include <net-snmp/net-snmp-config.h>
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif


/*
 * minimal include directives 
 */
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>

#include "header_complex.h"
#include "mteTriggerTable.h"
#include "mteTriggerBooleanTable.h"
#include "mteTriggerDeltaTable.h"
#include "mteTriggerExistenceTable.h"
#include "mteTriggerThresholdTable.h"
#include "mteEventTable.h"
#include "mteObjectsTable.h"

/*
 * mteTriggerTable_variables_oid:
 *   this is the top level oid that we want to register under.  This
 *   is essentially a prefix, with the suffix appearing in the
 *   variable below.
 */

/*
 * trap definitions 
 */
oid             mteTriggerFired[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 1 };
oid             mteTriggerRising[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 2 };
oid             mteTriggerFalling[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 3 };
oid             mteTriggerFailure[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 4 };
oid             mteEventSetFailure[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 5 };

/*
 * trap objects 
 */
oid             mteHotTrigger[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 1 };
oid             mteHotTargetName[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 2 };
oid             mteHotContextName[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 3 };
oid             mteHotOID[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 4 };
oid             mteHotValue[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 5 };
oid             mteFailedReason[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 6 };

/*
 * For discontinuity checking.  
 */
oid             sysUpTimeInstance[] = { 1, 3, 6, 1, 2, 1, 1, 3, 0 };

oid             mteTriggerTable_variables_oid[] =
    { 1, 3, 6, 1, 2, 1, 88, 1, 2, 2 };


/*
 * variable2 mteTriggerTable_variables:
 *   this variable defines function callbacks and type return information 
 *   for the mteTriggerTable mib section 
 */


struct variable2 mteTriggerTable_variables[] = {
    /*
     * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
     */
#define   MTETRIGGERCOMMENT     5
    {MTETRIGGERCOMMENT, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 3}},
#define   MTETRIGGERTEST        6
    {MTETRIGGERTEST, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 4}},
#define   MTETRIGGERSAMPLETYPE  7
    {MTETRIGGERSAMPLETYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 5}},
#define   MTETRIGGERVALUEID     8
    {MTETRIGGERVALUEID, ASN_OBJECT_ID, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 6}},
#define   MTETRIGGERVALUEIDWILDCARD  9
    {MTETRIGGERVALUEIDWILDCARD, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 7}},
#define   MTETRIGGERTARGETTAG   10
    {MTETRIGGERTARGETTAG, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 8}},
#define   MTETRIGGERCONTEXTNAME  11
    {MTETRIGGERCONTEXTNAME, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 9}},
#define   MTETRIGGERCONTEXTNAMEWILDCARD  12
    {MTETRIGGERCONTEXTNAMEWILDCARD, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 10}},
#define   MTETRIGGERFREQUENCY   13
    {MTETRIGGERFREQUENCY, ASN_UNSIGNED, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 11}},
#define   MTETRIGGEROBJECTSOWNER  14
    {MTETRIGGEROBJECTSOWNER, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 12}},
#define   MTETRIGGEROBJECTS     15
    {MTETRIGGEROBJECTS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 13}},
#define   MTETRIGGERENABLED     16
    {MTETRIGGERENABLED, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 14}},
#define   MTETRIGGERENTRYSTATUS  17
    {MTETRIGGERENTRYSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
     var_mteTriggerTable, 2, {1, 15}},

};
/*
 * (L = length of the oidsuffix) 
 */


/*
 * global storage of our data, saved in and configured by header_complex() 
 */
struct header_complex_index *mteTriggerTableStorage = NULL;

netsnmp_session *mte_callback_sess = NULL;
extern int      callback_master_num;

/*
 * init_mteTriggerTable():
 *   Initialization routine.  This is called when the agent starts up.
 *   At a minimum, registration of your variables should take place here.
 */
void
init_mteTriggerTable(void)
{
    DEBUGMSGTL(("mteTriggerTable", "initializing...  "));

#ifndef NETSNMP_TRANSPORT_CALLBACK_DOMAIN
    snmp_log(LOG_WARNING,"mteTriggerTable has been disabled because "
               "the callback transport is not available.\n");
    return;
#endif

    /*
     * register ourselves with the agent to handle our mib tree 
     */
    REGISTER_MIB("mteTriggerTable", mteTriggerTable_variables, variable2,
                 mteTriggerTable_variables_oid);


    /*
     * register our config handler(s) to deal with registrations 
     */
    snmpd_register_config_handler("mteTriggerTable", parse_mteTriggerTable,
                                  NULL, NULL);

    snmpd_register_config_handler("monitor", parse_simple_monitor, NULL,
                                  "[options] monitor_expression [see \"man snmpd.conf\"]");
    snmpd_register_config_handler("defaultMonitors",
                                  parse_default_monitors, NULL, "yes|no");

    /*
     * we need to be called back later to store our data 
     */
    snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
                           store_mteTriggerTable, NULL);


    /*
     * place any other initialization junk you need here 
     */
    se_add_pair_to_slist("mteBooleanOperators", strdup("!="),
                         MTETRIGGERBOOLEANCOMPARISON_UNEQUAL);
    se_add_pair_to_slist("mteBooleanOperators", strdup("=="),
                         MTETRIGGERBOOLEANCOMPARISON_EQUAL);
    se_add_pair_to_slist("mteBooleanOperators", strdup("<"),
                         MTETRIGGERBOOLEANCOMPARISON_LESS);
    se_add_pair_to_slist("mteBooleanOperators", strdup("<="),
                         MTETRIGGERBOOLEANCOMPARISON_LESSOREQUAL);
    se_add_pair_to_slist("mteBooleanOperators", strdup(">"),
                         MTETRIGGERBOOLEANCOMPARISON_GREATER);
    se_add_pair_to_slist("mteBooleanOperators", strdup(">="),
                         MTETRIGGERBOOLEANCOMPARISON_GREATEROREQUAL);

    DEBUGMSGTL(("mteTriggerTable", "done.\n"));
}

struct mteTriggerTable_data *
create_mteTriggerTable_data(void)
{
    struct mteTriggerTable_data *StorageNew;

    StorageNew = SNMP_MALLOC_STRUCT(mteTriggerTable_data);

    /*
     * fill in default row values here into StorageNew 
     */
    /*
     * fill in values for all tables (even if not
     * appropriate), since its easier to do here than anywhere
     * else 
     */
    StorageNew->mteTriggerComment = strdup("");
    StorageNew->mteTriggerTest = strdup("");
    StorageNew->mteTriggerTest[0] |= (char) MTETRIGGERTEST_BOOLEAN;
    StorageNew->mteTriggerTestLen = 1;
    StorageNew->mteTriggerSampleType = MTETRIGGERSAMPLETYPE_ABSOLUTEVALUE;
    StorageNew->mteTriggerValueID = calloc(1, sizeof(oid) * sizeof(2)); /* 0.0 */
    StorageNew->mteTriggerValueIDLen = 2;
    StorageNew->mteTriggerValueIDWildcard =
        MTETRIGGERVALUEIDWILDCARD_FALSE;
    StorageNew->mteTriggerTargetTag = strdup("");
    StorageNew->mteTriggerContextName = strdup("");
    StorageNew->mteTriggerContextNameWildcard =
        MTETRIGGERCONTEXTNAMEWILDCARD_FALSE;
    StorageNew->mteTriggerFrequency = 600;
    StorageNew->mteTriggerObjectsOwner = strdup("");
    StorageNew->mteTriggerObjects = strdup("");
    StorageNew->mteTriggerEnabled = MTETRIGGERENABLED_FALSE;
    StorageNew->mteTriggerDeltaDiscontinuityID =
        netsnmp_memdup(sysUpTimeInstance, sizeof(sysUpTimeInstance));
    StorageNew->mteTriggerDeltaDiscontinuityIDLen =
        sizeof(sysUpTimeInstance) / sizeof(oid);
    StorageNew->mteTriggerDeltaDiscontinuityIDWildcard = TV_FALSE;
    StorageNew->mteTriggerDeltaDiscontinuityIDType =
        MTETRIGGERDELTADISCONTINUITYIDTYPE_TIMETICKS;
    StorageNew->mteTriggerExistenceTest = strdup("");
    StorageNew->mteTriggerExistenceTest[0] =
        (char) (MTETRIGGEREXISTENCETEST_PRESENT |
                MTETRIGGEREXISTENCETEST_ABSENT);
    StorageNew->mteTriggerExistenceTestLen = 1;
    StorageNew->mteTriggerExistenceStartup = strdup("");
    StorageNew->mteTriggerExistenceStartup[0] =
        (char) (MTETRIGGEREXISTENCESTARTUP_PRESENT);
    StorageNew->mteTriggerExistenceStartupLen = 1;
    StorageNew->mteTriggerExistenceObjectsOwner = strdup("");
    StorageNew->mteTriggerExistenceObjects = strdup("");
    StorageNew->mteTriggerExistenceEventOwner = strdup("");
    StorageNew->mteTriggerExistenceEvent = strdup("");
    StorageNew->mteTriggerBooleanComparison =
        MTETRIGGERBOOLEANCOMPARISON_UNEQUAL;
    StorageNew->mteTriggerBooleanStartup = MTETRIGGERBOOLEANSTARTUP_TRUE;
    StorageNew->mteTriggerBooleanObjectsOwner = strdup("");
    StorageNew->mteTriggerBooleanObjects = strdup("");
    StorageNew->mteTriggerBooleanEventOwner = strdup("");
    StorageNew->mteTriggerBooleanEvent = strdup("");
    StorageNew->mteTriggerThresholdStartup =
        MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING;
    StorageNew->mteTriggerThresholdObjectsOwner = strdup("");
    StorageNew->mteTriggerThresholdObjects = strdup("");
    StorageNew->mteTriggerThresholdRisingEventOwner = strdup("");
    StorageNew->mteTriggerThresholdRisingEvent = strdup("");
    StorageNew->mteTriggerThresholdFallingEventOwner = strdup("");
    StorageNew->mteTriggerThresholdFallingEvent = strdup("");
    StorageNew->mteTriggerThresholdDeltaRisingEventOwner = strdup("");
    StorageNew->mteTriggerThresholdDeltaRisingEvent = strdup("");
    StorageNew->mteTriggerThresholdDeltaFallingEventOwner = strdup("");
    StorageNew->mteTriggerThresholdDeltaFallingEvent = strdup("");
    StorageNew->lastboolresult = -1;
    StorageNew->storageType = ST_NONVOLATILE;
    StorageNew->prevDiscoTicks = 0;
    StorageNew->prevUptimeTicks = 0;
    return StorageNew;
}

/*
 * mteTriggerTable_add(): adds a structure node to our data set 
 */
int
mteTriggerTable_add(struct mteTriggerTable_data *thedata)
{
    netsnmp_variable_list *vars = NULL;


    DEBUGMSGTL(("mteTriggerTable", "adding data...  "));
    /*
     * add the index variables to the varbind list, which is 
     * used by header_complex to index the data 
     */


    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->mteOwner, thedata->mteOwnerLen); /* mteOwner */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, (char *) thedata->mteTriggerName, thedata->mteTriggerNameLen);        /* mteTriggerName */


    header_complex_add_data(&mteTriggerTableStorage, vars, thedata);
    DEBUGMSGTL(("mteTriggerTable", "registered an entry\n"));


    DEBUGMSGTL(("mteTriggerTable", "done.\n"));
    return SNMPERR_SUCCESS;
}


#define MTE_PROCESS_LINE(line) \
  snprintf(buf, SPRINT_MAX_LEN, "-u %s %s", mte_default_user, line); \
  parse_simple_monitor("monitor", buf);

void
parse_default_monitors(const char *token, char *line)
{
    char            buf[SPRINT_MAX_LEN];
    char           *mte_default_user =
        netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_SECNAME);

    if (strncmp(line, "yes", 3) == 0) {

        DEBUGMSGTL(("mteTriggerTable", "registering default monitors\n"));

        if (mte_default_user == NULL) {
            config_perror
                ("You must specify a user name first using the agentSecName token\n");
            return;
        }

        /*
         * we don't include many additional objects here as most of
         * the error messages are complete with the needed
         * information 
         */
        MTE_PROCESS_LINE
            ("-o prNames -o prErrMessage \"process table\" prErrorFlag != 0");
        MTE_PROCESS_LINE
            ("-o memErrorName -o memSwapErrorMsg \"memory\" memSwapError != 0");
        MTE_PROCESS_LINE
            ("-o extNames -o extOutput \"extTable\" extResult != 0");
        MTE_PROCESS_LINE
            ("-o dskPath -o dskErrorMsg \"dskTable\" dskErrorFlag != 0");
        MTE_PROCESS_LINE
            ("-o laNames -o laErrMessage  \"laTable\" laErrorFlag != 0");
        MTE_PROCESS_LINE
            ("-o fileName -o fileErrorMsg  \"fileTable\" fileErrorFlag != 0");
        /*
         * this one is not *all* that useful, because the error is
         * only kept for 30 seconds at most.  Maybe scan it every 30
         * seconds, but I'm not doing so without seeking other peoples
         * opinions first. 
         */
        MTE_PROCESS_LINE
            ("-o snmperrErrMessage  \"snmperrs\" snmperrErrorFlag != 0");
    }
}

static int      monitor_call_count = 0;
void
parse_simple_monitor(const char *token, char *line)
{
    char            buf[SPRINT_MAX_LEN], *cp, eventname[64];
    oid             obuf[MAX_OID_LEN];
    size_t          obufLen;
    struct mteTriggerTable_data *StorageNew;

    monitor_call_count++;
    eventname[0] = '\0';

    StorageNew = create_mteTriggerTable_data();
    StorageNew->storageType = ST_READONLY;
    StorageNew->mteTriggerEnabled = MTETRIGGERENABLED_TRUE;
    StorageNew->mteTriggerEntryStatus = RS_ACTIVE;
    StorageNew->mteTriggerValueIDWildcard = MTETRIGGERVALUEIDWILDCARD_TRUE;
    StorageNew->mteTriggerBooleanStartup = MTETRIGGERBOOLEANSTARTUP_TRUE;
    StorageNew->mteTriggerThresholdStartup =
        MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING;
    StorageNew->mteTriggerExistenceTest[0] = 0;

    /*
     * owner = snmpd.conf, why not? 
     */
    StorageNew->mteOwner = strdup("snmpd.conf");
    StorageNew->mteOwnerLen = strlen(StorageNew->mteOwner);
    StorageNew->pdu_version = SNMP_VERSION_3;
    StorageNew->pdu_securityModel = SNMP_SEC_MODEL_USM;
    StorageNew->pdu_securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;

    cp = line;

    while (cp && *cp == '-') {
        cp = copy_nword(cp, buf, sizeof(buf));
        switch (buf[1]) {
        case 't':
           /*
            * Threshold toggle
            */
           StorageNew->mteTriggerTest[0] = MTETRIGGERTEST_THRESHOLD;
           break;
        case 'i':
           /*
            * Single instance
            */
           StorageNew->mteTriggerValueIDWildcard = MTETRIGGERVALUEIDWILDCARD_FALSE;
           break;
        case 'r':
            if (cp) {
                cp = copy_nword(cp, buf, sizeof(buf));
                StorageNew->mteTriggerFrequency = strtoul(buf, NULL, 0);
            } else {
                config_perror("No parameter after -r given\n");
                /*
                 * XXX: free StorageNew 
                 */
                return;
            }
            break;
        case 'u':
            if (cp) {
                cp = copy_nword(cp, buf, sizeof(buf));
                StorageNew->pdu_securityName = strdup(buf);
                StorageNew->pdu_securityNameLen = strlen(buf);
            } else {
                config_perror("No parameter after -u given\n");
                /*
                 * XXX: free StorageNew 
                 */
                return;
            }
            break;
        case 'e':
            if (cp) {
                cp = copy_nword(cp, eventname, sizeof(eventname));
            } else {
                config_perror("No parameter after -e given\n");
                /*
                 * XXX: free StorageNew 
                 */
                return;
            }
            break;
        case 'o':
            /*
             * oid 
             */
            cp = copy_nword(cp, buf, sizeof(buf));
            obufLen = MAX_OID_LEN;
            if (!snmp_parse_oid(buf, obuf, &obufLen)) {
		netsnmp_config_error("unable to parse oid: %s", buf);
                /*
                 * XXX: free StorageNew 
                 */
                return;
            }
            sprintf(buf, "snmpd.conf%d", monitor_call_count);
            mte_add_object_to_table("snmpd.conf", buf, obuf, obufLen, 1);

            if (StorageNew->mteTriggerObjectsOwnerLen == 0) {
                SNMP_FREE(StorageNew->mteTriggerObjectsOwner);
                StorageNew->mteTriggerObjectsOwner = strdup("snmpd.conf");
                StorageNew->mteTriggerObjectsOwnerLen =
                    strlen("snmpd.conf");
            }

            if (StorageNew->mteTriggerObjectsLen == 0) {
                SNMP_FREE(StorageNew->mteTriggerObjects);
                StorageNew->mteTriggerObjects = strdup(buf);
                StorageNew->mteTriggerObjectsLen = strlen(buf);
            }
            break;
        }
    }

    if (StorageNew->pdu_securityNameLen == 0) {
        char           *mte_default_user =
            netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_SECNAME);
        if (mte_default_user) {
            StorageNew->pdu_securityName = strdup(mte_default_user);
            StorageNew->pdu_securityNameLen = strlen(mte_default_user);
        } else {
            config_perror("-u USER parameter required\n");
            /*
             * XXX: free StorageNew 
             */
            return;
        }
    }

    /*
     * name 
     */
    cp = copy_nword(cp, buf, sizeof(buf));
    if (!cp) {
        config_perror("illegal monitor: no name specified");
        /*
         * XXX: free StorageNew 
         */
        return;
    }

    StorageNew->mteTriggerName = strdup(buf);
    StorageNew->mteTriggerNameLen = strlen(StorageNew->mteTriggerName);

    /*
     * oid 
     */
    cp = copy_nword(cp, buf, sizeof(buf));
    obufLen = MAX_OID_LEN;
    if (!snmp_parse_oid(buf, obuf, &obufLen)) {
	netsnmp_config_error("unable to parse oid: %s", buf);
        /*
         * XXX: free StorageNew 
         */
        return;
    }
    if (StorageNew->mteTriggerValueID)
        free(StorageNew->mteTriggerValueID);
    StorageNew->mteTriggerValueID = snmp_duplicate_objid(obuf, obufLen);
    StorageNew->mteTriggerValueIDLen = obufLen;

    if (StorageNew->mteTriggerTest[0] == MTETRIGGERTEST_THRESHOLD) {
       /*
        * it's a threshold
        * grab 'low' and 'high' params
        */
        if (!cp) {
            config_perror("no lower threshold value specified");
       }
       cp = copy_nword(cp, buf, sizeof(buf));
       StorageNew->mteTriggerThresholdFalling = strtol(buf, NULL, 0);

        if (!cp) {
            config_perror("no upper threshold value specified");
       }
       cp = copy_nword(cp, buf, sizeof(buf));
       StorageNew->mteTriggerThresholdRising = strtol(buf, NULL, 0);
    } else {
        /*
         * if nothing beyond here, it's an existence test 
         */
        if (!cp) {
            StorageNew->mteTriggerTest[0] = (u_char)MTETRIGGERTEST_EXISTENCE;
            if (eventname[0] != '\0') {
                StorageNew->mteTriggerExistenceEventOwner =
                    strdup("snmpd.conf");
                StorageNew->mteTriggerExistenceEventOwnerLen =
                    strlen(StorageNew->mteTriggerExistenceEventOwner);
                StorageNew->mteTriggerExistenceEvent =
                    strdup(eventname);
                StorageNew->mteTriggerExistenceEventLen =
                    strlen(eventname);
            }
            mteTriggerTable_add(StorageNew);
            return;
        }

        /*
         * assume boolean (need to deal with threshold statements) 
         */
        cp = copy_nword(cp, buf, sizeof(buf));
        if ((StorageNew->mteTriggerBooleanComparison =
             se_find_value_in_slist("mteBooleanOperators", buf)) == -1) {
            config_perror("illegal boolean operator");
            return;
        }

        /*
         * XXX: add threshold 
         */
        StorageNew->mteTriggerTest[0] = MTETRIGGERTEST_BOOLEAN;
        if (!cp) {
            config_perror("no comparison value specified");
            /*
             * XXX: free StorageNew 
             */
            return;
        }

        cp = copy_nword(cp, buf, sizeof(buf));
        StorageNew->mteTriggerBooleanValue = strtol(buf, NULL, 0);

        if (eventname[0] != '\0') {
            StorageNew->mteTriggerBooleanEventOwner =
                strdup("snmpd.conf");
            StorageNew->mteTriggerBooleanEventOwnerLen =
                strlen(StorageNew->mteTriggerBooleanEventOwner);
            StorageNew->mteTriggerBooleanEvent =
                strdup(eventname);
            StorageNew->mteTriggerBooleanEventLen =
                strlen(eventname);
        }
    }
    mteTriggerTable_add(StorageNew);
    mte_enable_trigger(StorageNew);

    DEBUGMSGTL(("mteTriggerTable", "added simple monitor: %s\n",
                StorageNew->mteTriggerName));
}


/*
 * parse_mteTriggerTable():
 *   parses .conf file entries needed to configure the mib.
 */
void
parse_mteTriggerTable(const char *token, char *line)
{
    size_t          tmpint;
    oid            *tmpoid = NULL;
    struct mteTriggerTable_data *StorageTmp =
        SNMP_MALLOC_STRUCT(mteTriggerTable_data);

    DEBUGMSGTL(("mteTriggerTable", "parsing config...  "));

    if (StorageTmp == NULL) {
        config_perror("malloc failure");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->mteOwner,
                              &StorageTmp->mteOwnerLen);
    if (StorageTmp->mteOwner == NULL) {
        config_perror("invalid specification for mteOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerName,
                              &StorageTmp->mteTriggerNameLen);
    if (StorageTmp->mteTriggerName == NULL) {
        config_perror("invalid specification for mteTriggerName");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerComment,
                              &StorageTmp->mteTriggerCommentLen);
    if (StorageTmp->mteTriggerComment == NULL) {
        config_perror("invalid specification for mteTriggerComment");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerTest,
                              &StorageTmp->mteTriggerTestLen);
    if (StorageTmp->mteTriggerTest == NULL) {
        config_perror("invalid specification for mteTriggerTest");
        return;
    }

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerSampleType, &tmpint);

    line =
        read_config_read_data(ASN_OBJECT_ID, line,
                              &StorageTmp->mteTriggerValueID,
                              &StorageTmp->mteTriggerValueIDLen);
    if (StorageTmp->mteTriggerValueID == NULL) {
        config_perror("invalid specification for mteTriggerValueID");
        return;
    }

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerValueIDWildcard,
                              &tmpint);

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerTargetTag,
                              &StorageTmp->mteTriggerTargetTagLen);
    if (StorageTmp->mteTriggerTargetTag == NULL) {
        config_perror("invalid specification for mteTriggerTargetTag");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerContextName,
                              &StorageTmp->mteTriggerContextNameLen);
    if (StorageTmp->mteTriggerContextName == NULL) {
        config_perror("invalid specification for mteTriggerContextName");
        return;
    }

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerContextNameWildcard,
                              &tmpint);

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->mteTriggerFrequency, &tmpint);

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerObjectsOwner,
                              &StorageTmp->mteTriggerObjectsOwnerLen);
    if (StorageTmp->mteTriggerObjectsOwner == NULL) {
        config_perror("invalid specification for mteTriggerObjectsOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerObjects,
                              &StorageTmp->mteTriggerObjectsLen);
    if (StorageTmp->mteTriggerObjects == NULL) {
        config_perror("invalid specification for mteTriggerObjects");
        return;
    }

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerEnabled, &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerEntryStatus, &tmpint);

    /*
     * delta table 
     */
    line =
        read_config_read_data(ASN_OBJECT_ID, line,
                              &StorageTmp->mteTriggerDeltaDiscontinuityID,
                              &StorageTmp->
                              mteTriggerDeltaDiscontinuityIDLen);
    if (StorageTmp->mteTriggerDeltaDiscontinuityID == NULL) {
        config_perror
            ("invalid specification for mteTriggerDeltaDiscontinuityID");
        return;
    }

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->
                              mteTriggerDeltaDiscontinuityIDWildcard,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->
                              mteTriggerDeltaDiscontinuityIDType, &tmpint);

    /*
     * existence table 
     */
    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerExistenceTest,
                              &StorageTmp->mteTriggerExistenceTestLen);
    if (StorageTmp->mteTriggerExistenceTest == NULL) {
        config_perror("invalid specification for mteTriggerExistenceTest");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerExistenceStartup,
                              &StorageTmp->mteTriggerExistenceStartupLen);
    if (StorageTmp->mteTriggerExistenceStartup == NULL) {
        config_perror
            ("invalid specification for mteTriggerExistenceStartup");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerExistenceObjectsOwner,
                              &StorageTmp->
                              mteTriggerExistenceObjectsOwnerLen);
    if (StorageTmp->mteTriggerExistenceObjectsOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerExistenceObjectsOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerExistenceObjects,
                              &StorageTmp->mteTriggerExistenceObjectsLen);
    if (StorageTmp->mteTriggerExistenceObjects == NULL) {
        config_perror
            ("invalid specification for mteTriggerExistenceObjects");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerExistenceEventOwner,
                              &StorageTmp->
                              mteTriggerExistenceEventOwnerLen);
    if (StorageTmp->mteTriggerExistenceEventOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerExistenceEventOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerExistenceEvent,
                              &StorageTmp->mteTriggerExistenceEventLen);
    if (StorageTmp->mteTriggerExistenceEvent == NULL) {
        config_perror
            ("invalid specification for mteTriggerExistenceEvent");
        return;
    }

    /*
     * boolean table 
     */
    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerBooleanComparison,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerBooleanValue,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerBooleanStartup,
                              &tmpint);

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerBooleanObjectsOwner,
                              &StorageTmp->
                              mteTriggerBooleanObjectsOwnerLen);
    if (StorageTmp->mteTriggerBooleanObjectsOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerBooleanObjectsOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerBooleanObjects,
                              &StorageTmp->mteTriggerBooleanObjectsLen);
    if (StorageTmp->mteTriggerBooleanObjects == NULL) {
        config_perror
            ("invalid specification for mteTriggerBooleanObjects");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerBooleanEventOwner,
                              &StorageTmp->mteTriggerBooleanEventOwnerLen);
    if (StorageTmp->mteTriggerBooleanEventOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerBooleanEventOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerBooleanEvent,
                              &StorageTmp->mteTriggerBooleanEventLen);
    if (StorageTmp->mteTriggerBooleanEvent == NULL) {
        config_perror("invalid specification for mteTriggerBooleanEvent");
        return;
    }

    /*
     * threshold table 
     */
    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerThresholdStartup,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerThresholdRising,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerThresholdFalling,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerThresholdDeltaRising,
                              &tmpint);

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->mteTriggerThresholdDeltaFalling,
                              &tmpint);

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerThresholdObjectsOwner,
                              &StorageTmp->
                              mteTriggerThresholdObjectsOwnerLen);
    if (StorageTmp->mteTriggerThresholdObjectsOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdObjectsOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerThresholdObjects,
                              &StorageTmp->mteTriggerThresholdObjectsLen);
    if (StorageTmp->mteTriggerThresholdObjects == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdObjects");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->
                              mteTriggerThresholdRisingEventOwner,
                              &StorageTmp->
                              mteTriggerThresholdRisingEventOwnerLen);
    if (StorageTmp->mteTriggerThresholdRisingEventOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdRisingEventOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerThresholdRisingEvent,
                              &StorageTmp->
                              mteTriggerThresholdRisingEventLen);
    if (StorageTmp->mteTriggerThresholdRisingEvent == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdRisingEvent");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->
                              mteTriggerThresholdFallingEventOwner,
                              &StorageTmp->
                              mteTriggerThresholdFallingEventOwnerLen);
    if (StorageTmp->mteTriggerThresholdFallingEventOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdFallingEventOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->mteTriggerThresholdFallingEvent,
                              &StorageTmp->
                              mteTriggerThresholdFallingEventLen);
    if (StorageTmp->mteTriggerThresholdFallingEvent == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdFallingEvent");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->
                              mteTriggerThresholdDeltaRisingEventOwner,
                              &StorageTmp->
                              mteTriggerThresholdDeltaRisingEventOwnerLen);
    if (StorageTmp->mteTriggerThresholdDeltaRisingEventOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdDeltaRisingEventOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->
                              mteTriggerThresholdDeltaRisingEvent,
                              &StorageTmp->
                              mteTriggerThresholdDeltaRisingEventLen);
    if (StorageTmp->mteTriggerThresholdDeltaRisingEvent == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdDeltaRisingEvent");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->
                              mteTriggerThresholdDeltaFallingEventOwner,
                              &StorageTmp->
                              mteTriggerThresholdDeltaFallingEventOwnerLen);
    if (StorageTmp->mteTriggerThresholdDeltaFallingEventOwner == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdDeltaFallingEventOwner");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->
                              mteTriggerThresholdDeltaFallingEvent,
                              &StorageTmp->
                              mteTriggerThresholdDeltaFallingEventLen);
    if (StorageTmp->mteTriggerThresholdDeltaFallingEvent == NULL) {
        config_perror
            ("invalid specification for mteTriggerThresholdDeltaFallingEvent");
        return;
    }

    /*
     * local internal variables 
     */
    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->have_copied_auth_info, &tmpint);
    if (StorageTmp->have_copied_auth_info) {
        line =
            read_config_read_data(ASN_INTEGER, line,
                                  &StorageTmp->pdu_version, &tmpint);
        line =
            read_config_read_data(ASN_INTEGER, line,
                                  &StorageTmp->pdu_securityModel, &tmpint);
        line =
            read_config_read_data(ASN_INTEGER, line,
                                  &StorageTmp->pdu_securityLevel, &tmpint);
        line =
            read_config_read_data(ASN_OBJECT_ID, line, &tmpoid, &tmpint);
        if (!netsnmp_tdomain_support
            (tmpoid, tmpint, &StorageTmp->pdu_tDomain,
             &StorageTmp->pdu_tDomainLen)) {
            config_perror
                ("unsupported transport domain for mteTriggerEntry");
            return;
        }
        if (tmpoid != NULL) {
            free(tmpoid);
        }

        /*
         * can be NULL?  Yes.  
         */
        line = read_config_read_data(ASN_OCTET_STR, line,
                                     &(StorageTmp->pdu_transport),
                                     &StorageTmp->pdu_transportLen);

        line =
            read_config_read_data(ASN_OCTET_STR, line,
                                  &StorageTmp->pdu_community,
                                  &StorageTmp->pdu_community_len);
        if (StorageTmp->pdu_community == NULL) {
            config_perror("invalid specification for pdu_community");
            return;
        }
        line =
            read_config_read_data(ASN_OCTET_STR, line,
                                  &StorageTmp->pdu_securityName,
                                  &StorageTmp->pdu_securityNameLen);
        if (StorageTmp->pdu_securityName == NULL) {
            config_perror("invalid specification for pdu_securityName");
            return;
        }
    }
    StorageTmp->storageType = ST_NONVOLATILE;   /* the only type stored */

    mteTriggerTable_add(StorageTmp);

    /*
     * technically this is too early 
     */
    if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
        StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
        mte_enable_trigger(StorageTmp);

    DEBUGMSGTL(("mteTriggerTable", "done.\n"));
}


/*
 * store_mteTriggerTable():
 *   stores .conf file entries needed to configure the mib.
 */
int
store_mteTriggerTable(int majorID, int minorID, void *serverarg,
                      void *clientarg)
{
    char            line[SNMP_MAXBUF];
    char           *cptr;
    size_t          tmpint;
    struct mteTriggerTable_data *StorageTmp;
    struct header_complex_index *hcindex;

    DEBUGMSGTL(("mteTriggerTable", "storing data...  "));

    for (hcindex = mteTriggerTableStorage; hcindex != NULL;
         hcindex = hcindex->next) {
        StorageTmp = (struct mteTriggerTable_data *) hcindex->data;


        if (StorageTmp->storageType == ST_NONVOLATILE) {

            memset(line, 0, sizeof(line));
            strcat(line, "mteTriggerTable ");
            cptr = line + strlen(line);

            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteOwner,
                                       &StorageTmp->mteOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerName,
                                       &StorageTmp->mteTriggerNameLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerComment,
                                       &StorageTmp->mteTriggerCommentLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerTest,
                                       &StorageTmp->mteTriggerTestLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->mteTriggerSampleType,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_OBJECT_ID, cptr,
                                       &StorageTmp->mteTriggerValueID,
                                       &StorageTmp->mteTriggerValueIDLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerValueIDWildcard, &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerTargetTag,
                                       &StorageTmp->
                                       mteTriggerTargetTagLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerContextName,
                                       &StorageTmp->
                                       mteTriggerContextNameLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerContextNameWildcard,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->mteTriggerFrequency,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerObjectsOwner,
                                       &StorageTmp->
                                       mteTriggerObjectsOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerObjects,
                                       &StorageTmp->mteTriggerObjectsLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->mteTriggerEnabled,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->mteTriggerEntryStatus,
                                       &tmpint);

            /*
             * delta table 
             */
            cptr =
                read_config_store_data(ASN_OBJECT_ID, cptr,
                                       &StorageTmp->
                                       mteTriggerDeltaDiscontinuityID,
                                       &StorageTmp->
                                       mteTriggerDeltaDiscontinuityIDLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerDeltaDiscontinuityIDWildcard,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerDeltaDiscontinuityIDType,
                                       &tmpint);

            /*
             * existence table 
             */
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerExistenceTest,
                                       &StorageTmp->
                                       mteTriggerExistenceTestLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerExistenceStartup,
                                       &StorageTmp->
                                       mteTriggerExistenceStartupLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerExistenceObjectsOwner,
                                       &StorageTmp->
                                       mteTriggerExistenceObjectsOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerExistenceObjects,
                                       &StorageTmp->
                                       mteTriggerExistenceObjectsLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerExistenceEventOwner,
                                       &StorageTmp->
                                       mteTriggerExistenceEventOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerExistenceEvent,
                                       &StorageTmp->
                                       mteTriggerExistenceEventLen);

            /*
             * boolean table 
             */
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerBooleanComparison,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->mteTriggerBooleanValue,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerBooleanStartup, &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerBooleanObjectsOwner,
                                       &StorageTmp->
                                       mteTriggerBooleanObjectsOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerBooleanObjects,
                                       &StorageTmp->
                                       mteTriggerBooleanObjectsLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerBooleanEventOwner,
                                       &StorageTmp->
                                       mteTriggerBooleanEventOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->mteTriggerBooleanEvent,
                                       &StorageTmp->
                                       mteTriggerBooleanEventLen);

            /*
             * threshold table 
             */
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdStartup,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdRising, &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdFalling,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaRising,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaFalling,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdObjectsOwner,
                                       &StorageTmp->
                                       mteTriggerThresholdObjectsOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdObjects,
                                       &StorageTmp->
                                       mteTriggerThresholdObjectsLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdRisingEventOwner,
                                       &StorageTmp->
                                       mteTriggerThresholdRisingEventOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdRisingEvent,
                                       &StorageTmp->
                                       mteTriggerThresholdRisingEventLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdFallingEventOwner,
                                       &StorageTmp->
                                       mteTriggerThresholdFallingEventOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdFallingEvent,
                                       &StorageTmp->
                                       mteTriggerThresholdFallingEventLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaRisingEventOwner,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaRisingEventOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaRisingEvent,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaRisingEventLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaFallingEventOwner,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaFallingEventOwnerLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaFallingEvent,
                                       &StorageTmp->
                                       mteTriggerThresholdDeltaFallingEventLen);

            /*
             * local internal variables 
             */
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->have_copied_auth_info,
                                       &tmpint);
            if (StorageTmp->have_copied_auth_info) {
                cptr =
                    read_config_store_data(ASN_INTEGER, cptr,
                                           &StorageTmp->pdu_version,
                                           &tmpint);
                cptr =
                    read_config_store_data(ASN_INTEGER, cptr,
                                           &StorageTmp->pdu_securityModel,
                                           &tmpint);
                cptr =
                    read_config_store_data(ASN_INTEGER, cptr,
                                           &StorageTmp->pdu_securityLevel,
                                           &tmpint);
                cptr =
                    read_config_store_data(ASN_OBJECT_ID, cptr,
                                           (void *)(&StorageTmp->pdu_tDomain),
                                           &StorageTmp->pdu_tDomainLen);
                cptr =
                    read_config_store_data(ASN_OCTET_STR, cptr,
                                           &StorageTmp->pdu_transport,
                                           &StorageTmp->pdu_transportLen);
                cptr =
                    read_config_store_data(ASN_OCTET_STR, cptr,
                                           &StorageTmp->pdu_community,
                                           &StorageTmp->pdu_community_len);
                cptr =
                    read_config_store_data(ASN_OCTET_STR, cptr,
                                           &StorageTmp->pdu_securityName,
                                           &StorageTmp->
                                           pdu_securityNameLen);
            }

            snmpd_store_config(line);
        }
    }
    DEBUGMSGTL(("mteTriggerTable", "done.\n"));
    return SNMPERR_SUCCESS;
}


/*
 * var_mteTriggerTable():
 *   Handle this table separately from the scalar value case.
 *   The workings of this are basically the same as for var_mteTriggerTable above.
 */
unsigned char  *
var_mteTriggerTable(struct variable *vp,
                    oid * name,
                    size_t * length,
                    int exact,
                    size_t * var_len, WriteMethod ** write_method)
{


    struct mteTriggerTable_data *StorageTmp = NULL;


    DEBUGMSGTL(("mteTriggerTable",
                "var_mteTriggerTable: Entering...  \n"));
    /*
     * this assumes you have registered all your data properly
     */
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, vp, name, length, exact,
                        var_len, write_method)) == NULL) {
        if (vp->magic == MTETRIGGERENTRYSTATUS)
            *write_method = write_mteTriggerEntryStatus;
        return NULL;
    }


    /*
     * this is where we do the value assignments for the mib results.
     */
    switch (vp->magic) {


    case MTETRIGGERCOMMENT:
        *write_method = write_mteTriggerComment;
        *var_len = StorageTmp->mteTriggerCommentLen;
        return (u_char *) StorageTmp->mteTriggerComment;

    case MTETRIGGERTEST:
        *write_method = write_mteTriggerTest;
        *var_len = StorageTmp->mteTriggerTestLen;
        return (u_char *) StorageTmp->mteTriggerTest;

    case MTETRIGGERSAMPLETYPE:
        *write_method = write_mteTriggerSampleType;
        *var_len = sizeof(StorageTmp->mteTriggerSampleType);
        return (u_char *) & StorageTmp->mteTriggerSampleType;

    case MTETRIGGERVALUEID:
        *write_method = write_mteTriggerValueID;
        *var_len = StorageTmp->mteTriggerValueIDLen * sizeof(oid);
        return (u_char *) StorageTmp->mteTriggerValueID;

    case MTETRIGGERVALUEIDWILDCARD:
        *write_method = write_mteTriggerValueIDWildcard;
        *var_len = sizeof(StorageTmp->mteTriggerValueIDWildcard);
        return (u_char *) & StorageTmp->mteTriggerValueIDWildcard;

    case MTETRIGGERTARGETTAG:
        *write_method = write_mteTriggerTargetTag;
        *var_len = StorageTmp->mteTriggerTargetTagLen;
        return (u_char *) StorageTmp->mteTriggerTargetTag;

    case MTETRIGGERCONTEXTNAME:
        *write_method = write_mteTriggerContextName;
        *var_len = StorageTmp->mteTriggerContextNameLen;
        return (u_char *) StorageTmp->mteTriggerContextName;

    case MTETRIGGERCONTEXTNAMEWILDCARD:
        *write_method = write_mteTriggerContextNameWildcard;
        *var_len = sizeof(StorageTmp->mteTriggerContextNameWildcard);
        return (u_char *) & StorageTmp->mteTriggerContextNameWildcard;

    case MTETRIGGERFREQUENCY:
        *write_method = write_mteTriggerFrequency;
        *var_len = sizeof(StorageTmp->mteTriggerFrequency);
        return (u_char *) & StorageTmp->mteTriggerFrequency;

    case MTETRIGGEROBJECTSOWNER:
        *write_method = write_mteTriggerObjectsOwner;
        *var_len = StorageTmp->mteTriggerObjectsOwnerLen;
        return (u_char *) StorageTmp->mteTriggerObjectsOwner;

    case MTETRIGGEROBJECTS:
        *write_method = write_mteTriggerObjects;
        *var_len = StorageTmp->mteTriggerObjectsLen;
        return (u_char *) StorageTmp->mteTriggerObjects;

    case MTETRIGGERENABLED:
        *write_method = write_mteTriggerEnabled;
        *var_len = sizeof(StorageTmp->mteTriggerEnabled);
        return (u_char *) & StorageTmp->mteTriggerEnabled;

    case MTETRIGGERENTRYSTATUS:
        *write_method = write_mteTriggerEntryStatus;
        *var_len = sizeof(StorageTmp->mteTriggerEntryStatus);
        return (u_char *) & StorageTmp->mteTriggerEntryStatus;


    default:
        ERROR_MSG("");
    }
    return NULL;
}


int
write_mteTriggerComment(int action,
                        u_char * var_val,
                        u_char var_val_type,
                        size_t var_val_len,
                        u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerComment entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerComment not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;

        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in string for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerComment;
        tmplen = StorageTmp->mteTriggerCommentLen;
        StorageTmp->mteTriggerComment = netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerCommentLen = var_val_len;
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerComment);
        StorageTmp->mteTriggerComment = tmpvar;
        StorageTmp->mteTriggerCommentLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerTest(int action,
                     u_char * var_val,
                     u_char var_val_type,
                     size_t var_val_len,
                     u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerTest entering action=%d...  \n", action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR, "write to mteTriggerTest not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in string for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerTest;
        tmplen = StorageTmp->mteTriggerTestLen;
        StorageTmp->mteTriggerTest = netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerTestLen = var_val_len;
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerTest);
        StorageTmp->mteTriggerTest = tmpvar;
        StorageTmp->mteTriggerTestLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerSampleType(int action,
                           u_char * var_val,
                           u_char var_val_type,
                           size_t var_val_len,
                           u_char * statP, oid * name, size_t name_len)
{
    static int      tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerSampleType entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_INTEGER) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerSampleType not ASN_INTEGER\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in long_ret for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerSampleType;
        StorageTmp->mteTriggerSampleType = *((long *) var_val);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        StorageTmp->mteTriggerSampleType = tmpvar;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */

        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerValueID(int action,
                        u_char * var_val,
                        u_char var_val_type,
                        size_t var_val_len,
                        u_char * statP, oid * name, size_t name_len)
{
    static oid     *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerValueID entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OBJECT_ID) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerValueID not ASN_OBJECT_ID\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in objid for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerValueID;
        tmplen = StorageTmp->mteTriggerValueIDLen;
        StorageTmp->mteTriggerValueID = netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerValueIDLen = var_val_len / sizeof(oid);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerValueID);
        StorageTmp->mteTriggerValueID = tmpvar;
        StorageTmp->mteTriggerValueIDLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */

        /*
         * XXX: if the valueID has actually changed, shouldn't we dump any
         * previous values, as these are from a different object?  
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerValueIDWildcard(int action,
                                u_char * var_val,
                                u_char var_val_type,
                                size_t var_val_len,
                                u_char * statP,
                                oid * name, size_t name_len)
{
    static int      tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerValueIDWildcard entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_INTEGER) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerValueIDWildcard not ASN_INTEGER\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in long_ret for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerValueIDWildcard;
        StorageTmp->mteTriggerValueIDWildcard = *((long *) var_val);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        StorageTmp->mteTriggerValueIDWildcard = tmpvar;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */

        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerTargetTag(int action,
                          u_char * var_val,
                          u_char var_val_type,
                          size_t var_val_len,
                          u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerTargetTag entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerTargetTag not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in string for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerTargetTag;
        tmplen = StorageTmp->mteTriggerTargetTagLen;
        StorageTmp->mteTriggerTargetTag = netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerTargetTagLen = var_val_len;
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerTargetTag);
        StorageTmp->mteTriggerTargetTag = tmpvar;
        StorageTmp->mteTriggerTargetTagLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerContextName(int action,
                            u_char * var_val,
                            u_char var_val_type,
                            size_t var_val_len,
                            u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerContextName entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerContextName not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in string for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerContextName;
        tmplen = StorageTmp->mteTriggerContextNameLen;
        StorageTmp->mteTriggerContextName =
            netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerContextNameLen = var_val_len;
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerContextName);
        StorageTmp->mteTriggerContextName = tmpvar;
        StorageTmp->mteTriggerContextNameLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerContextNameWildcard(int action,
                                    u_char * var_val,
                                    u_char var_val_type,
                                    size_t var_val_len,
                                    u_char * statP,
                                    oid * name, size_t name_len)
{
    static int      tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerContextNameWildcard entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_INTEGER) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerContextNameWildcard not ASN_INTEGER\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in long_ret for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerContextNameWildcard;
        StorageTmp->mteTriggerContextNameWildcard = *((long *) var_val);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        StorageTmp->mteTriggerContextNameWildcard = tmpvar;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */

        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerFrequency(int action,
                          u_char * var_val,
                          u_char var_val_type,
                          size_t var_val_len,
                          u_char * statP, oid * name, size_t name_len)
{
    static int      tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerFrequency entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_UNSIGNED) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerFrequency not ASN_UNSIGNED\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in ulong_ret for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerFrequency;
        StorageTmp->mteTriggerFrequency = *((unsigned long *) var_val);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        StorageTmp->mteTriggerFrequency = tmpvar;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
            StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
            mte_enable_trigger(StorageTmp);

        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerObjectsOwner(int action,
                             u_char * var_val,
                             u_char var_val_type,
                             size_t var_val_len,
                             u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerObjectsOwner entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerObjectsOwner not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in string for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerObjectsOwner;
        tmplen = StorageTmp->mteTriggerObjectsOwnerLen;
        StorageTmp->mteTriggerObjectsOwner =
            netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerObjectsOwnerLen = var_val_len;
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerObjectsOwner);
        StorageTmp->mteTriggerObjectsOwner = tmpvar;
        StorageTmp->mteTriggerObjectsOwnerLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerObjects(int action,
                        u_char * var_val,
                        u_char var_val_type,
                        size_t var_val_len,
                        u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerObjects entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerObjects not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in string for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerObjects;
        tmplen = StorageTmp->mteTriggerObjectsLen;
        StorageTmp->mteTriggerObjects = netsnmp_memdup(var_val, var_val_len);
        StorageTmp->mteTriggerObjectsLen = var_val_len;
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        SNMP_FREE(StorageTmp->mteTriggerObjects);
        StorageTmp->mteTriggerObjects = tmpvar;
        StorageTmp->mteTriggerObjectsLen = tmplen;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        SNMP_FREE(tmpvar);
        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerEnabled(int action,
                        u_char * var_val,
                        u_char var_val_type,
                        size_t var_val_len,
                        u_char * statP, oid * name, size_t name_len)
{
    static int      tmpvar;
    struct mteTriggerTable_data *StorageTmp = NULL;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);


    DEBUGMSGTL(("mteTriggerTable",
                "write_mteTriggerEnabled entering action=%d...  \n",
                action));
    if ((StorageTmp =
         header_complex(mteTriggerTableStorage, NULL,
                        &name[sizeof(mteTriggerTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */


    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_INTEGER) {
            snmp_log(LOG_ERR,
                     "write to mteTriggerEnabled not ASN_INTEGER\n");
            return SNMP_ERR_WRONGTYPE;
        }
        if (StorageTmp->storageType != ST_NONVOLATILE)
            return SNMP_ERR_NOTWRITABLE;
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in long_ret for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->mteTriggerEnabled;
        StorageTmp->mteTriggerEnabled = *((long *) var_val);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        StorageTmp->mteTriggerEnabled = tmpvar;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
            StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
            mte_enable_trigger(StorageTmp);
        else if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_FALSE)
            mte_disable_trigger(StorageTmp);


        break;
    }
    return SNMP_ERR_NOERROR;
}


int
write_mteTriggerEntryStatus(int action,
                            u_char * var_val,
                            u_char var_val_type,
                            size_t var_val_len,
                            u_char * statP, oid * name, size_t name_len)
{
    struct mteTriggerTable_data *StorageTmp = NULL;
    static struct mteTriggerTable_data *StorageNew, *StorageDel;
    size_t          newlen =
        name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                    3 - 1);
    static int      old_value;
    int             set_value;
    static netsnmp_variable_list *vars, *vp;
    struct header_complex_index *hciptr;

    StorageTmp =
        header_complex(mteTriggerTableStorage, NULL,
                       &name[sizeof(mteTriggerTable_variables_oid) /
                             sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);


    if (var_val_type != ASN_INTEGER || var_val == NULL) {
        snmp_log(LOG_ERR,
                 "write to mteTriggerEntryStatus not ASN_INTEGER\n");
        return SNMP_ERR_WRONGTYPE;
    }
    set_value = *((long *) var_val);


    /*
     * check legal range, and notReady is reserved for us, not a user 
     */
    if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
        return SNMP_ERR_INCONSISTENTVALUE;


    switch (action) {
    case RESERVE1:
        /*
         * stage one: test validity 
         */
        if (StorageTmp == NULL) {
            /*
             * create the row now? 
             */


            /*
             * ditch illegal values now 
             */
            if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
                return SNMP_ERR_INCONSISTENTVALUE;


            /*
             * destroying a non-existent row is actually legal 
             */
            if (set_value == RS_DESTROY) {
                return SNMP_ERR_NOERROR;
            }


            /*
             * illegal creation values 
             */
            if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
                return SNMP_ERR_INCONSISTENTVALUE;
            }
        } else {
            /*
             * row exists.  Check for a valid state change 
             */
            if (set_value == RS_CREATEANDGO
                || set_value == RS_CREATEANDWAIT) {
                /*
                 * can't create a row that exists 
                 */
                return SNMP_ERR_INCONSISTENTVALUE;
            }

            if (StorageTmp->mteTriggerEntryStatus == RS_ACTIVE &&
                set_value != RS_DESTROY) {
                /*
                 * "Once made active an entry may not be modified except to 
                 * delete it."  XXX: doesn't this in fact apply to ALL
                 * columns of the table and not just this one?  
                 */
                return SNMP_ERR_INCONSISTENTVALUE;
            }
            if (StorageTmp->storageType != ST_NONVOLATILE)
                return SNMP_ERR_NOTWRITABLE;
        }
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        if (StorageTmp == NULL) {
            /*
             * creation 
             */
            vars = NULL;


            snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0);  /* mteOwner */
            snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, NULL, 0);     /* mteTriggerName */


            if (header_complex_parse_oid
                (&
                 (name
                  [sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
                   2]), newlen, vars) != SNMPERR_SUCCESS) {
                /*
                 * XXX: free, zero vars 
                 */
                return SNMP_ERR_INCONSISTENTNAME;
            }
            vp = vars;


            StorageNew = create_mteTriggerTable_data();

            StorageNew->mteOwner = malloc(vp->val_len + 1);
            memcpy(StorageNew->mteOwner, vp->val.string, vp->val_len);
            StorageNew->mteOwner[vp->val_len] = '\0';
            StorageNew->mteOwnerLen = vp->val_len;

            vp = vp->next_variable;
            StorageNew->mteTriggerName = malloc(vp->val_len + 1);
            memcpy(StorageNew->mteTriggerName, vp->val.string,
                   vp->val_len);
            StorageNew->mteTriggerName[vp->val_len] = '\0';
            StorageNew->mteTriggerNameLen = vp->val_len;

            vp = vp->next_variable;

            StorageNew->mteTriggerEntryStatus = set_value;

        }


        break;


    case FREE:
        /*
         * XXX: free, zero vars 
         */
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in set_value for you to
         * use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in
         * the UNDO case 
         */


        if (StorageTmp == NULL) {
            /*
             * row creation, so add it 
             */
            if (StorageNew != NULL)
                mteTriggerTable_add(StorageNew);
            /*
             * XXX: ack, and if it is NULL? 
             */
        } else if (set_value != RS_DESTROY) {
            /*
             * set the flag? 
             */
            old_value = StorageTmp->mteTriggerEntryStatus;
            StorageTmp->mteTriggerEntryStatus = *((long *) var_val);
        } else {
            /*
             * destroy...  extract it for now 
             */
            hciptr =
                header_complex_find_entry(mteTriggerTableStorage,
                                          StorageTmp);
            StorageDel =
                header_complex_extract_entry(&mteTriggerTableStorage,
                                             hciptr);
        }
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        if (StorageTmp == NULL) {
            /*
             * row creation, so remove it again 
             */
            hciptr =
                header_complex_find_entry(mteTriggerTableStorage,
                                          StorageTmp);
            StorageDel =
                header_complex_extract_entry(&mteTriggerTableStorage,
                                             hciptr);
            /*
             * XXX: free it 
             */
        } else if (StorageDel != NULL) {
            /*
             * row deletion, so add it again 
             */
            mteTriggerTable_add(StorageDel);
        } else {
            StorageTmp->mteTriggerEntryStatus = old_value;
        }
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        if (StorageDel != NULL) {
            mte_disable_trigger(StorageDel);
            StorageDel = 0;
            /*
             * XXX: free it, its dead 
             */
        } else {
            if (StorageTmp
                && StorageTmp->mteTriggerEntryStatus == RS_CREATEANDGO) {
                StorageTmp->mteTriggerEntryStatus = RS_ACTIVE;
            } else if (StorageTmp &&
                       StorageTmp->mteTriggerEntryStatus ==
                       RS_CREATEANDWAIT) {
                StorageTmp->mteTriggerEntryStatus = RS_NOTINSERVICE;
            }
        }
        if (StorageTmp &&
            StorageTmp->mteTriggerEntryStatus == RS_ACTIVE &&
            !StorageTmp->have_copied_auth_info) {

            netsnmp_agent_session *asp =
                netsnmp_get_current_agent_session();
            netsnmp_pdu    *pdu = NULL;

            if (!asp) {
                snmp_log(LOG_ERR,
                         "snmpTriggerTable: can't get master session for authentication params\n");
            } else {
                pdu = asp->orig_pdu;
                if (!pdu) {
                    snmp_log(LOG_ERR,
                             "snmpTriggerTable: can't get master pdu for authentication params\n");
                }
            }

            if (pdu) {
                DEBUGMSGTL(("mteTriggerTest", "copying PDU auth info\n"));
                StorageTmp->pdu_version = pdu->version;
                StorageTmp->pdu_securityModel = pdu->securityModel;
                StorageTmp->pdu_securityLevel = pdu->securityLevel;
                StorageTmp->pdu_tDomain = pdu->tDomain;
                StorageTmp->pdu_tDomainLen = pdu->tDomainLen;
                if (pdu->transport_data != NULL) {
                    StorageTmp->pdu_transport =
                        malloc(pdu->transport_data_length);
                    memcpy(StorageTmp->pdu_transport, pdu->transport_data,
                           pdu->transport_data_length);
                }
                StorageTmp->pdu_transportLen = pdu->transport_data_length;
                if (pdu->community) {
                    StorageTmp->pdu_community =
                        calloc(1, pdu->community_len + 1);
                    memcpy(StorageTmp->pdu_community, pdu->community,
                           pdu->community_len);
                    StorageTmp->pdu_community_len = pdu->community_len;
                } else {
                    StorageTmp->pdu_community = NULL;
                    StorageTmp->pdu_community_len = 0;
                }
                if (pdu->securityName) {
                    StorageTmp->pdu_securityName =
                        calloc(1, pdu->securityNameLen + 1);
                    memcpy(StorageTmp->pdu_securityName, pdu->securityName,
                           pdu->securityNameLen);
                    StorageTmp->pdu_securityNameLen = pdu->securityNameLen;
                } else {
                    StorageTmp->pdu_securityName = NULL;
                    StorageTmp->pdu_securityNameLen = 0;
                }
                StorageTmp->have_copied_auth_info = 1;
            }
        }

        if (StorageTmp &&
            StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
            StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
            mte_enable_trigger(StorageTmp);
        break;
    }
    return SNMP_ERR_NOERROR;
}

/*
 * send trap 
 */
void
send_mte_trap(struct mteTriggerTable_data *item,
              oid * trap_oid, size_t trap_oid_len,
              oid * name_oid, size_t name_oid_len,
              long *value, const char *objowner, const char *objname,
              const char *reason)
{
    static oid      objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };     /* snmpTrapIOD.0 */

    netsnmp_variable_list *var_list = NULL;

    /*
     * snmpTrap oid 
     */
    snmp_varlist_add_variable(&var_list, objid_snmptrap,
                              sizeof(objid_snmptrap) / sizeof(oid),
                              ASN_OBJECT_ID, (u_char *) trap_oid,
                              trap_oid_len * sizeof(oid));

    /*
     * mteHotTrigger 
     */
    snmp_varlist_add_variable(&var_list, mteHotTrigger,
                              sizeof(mteHotTrigger) / sizeof(oid),
                              ASN_OCTET_STR,
                              (u_char *) item->mteTriggerName,
                              item->mteTriggerNameLen);

    /*
     * mteHotTargetName 
     */
    snmp_varlist_add_variable(&var_list, mteHotTargetName, sizeof(mteHotTargetName) / sizeof(oid), ASN_OCTET_STR, (u_char *) item->mteTriggerTargetTag, /*XXX: targetName,not tag */
                              item->mteTriggerTargetTagLen);    /*XXX */

    /*
     * mteHotContextName 
     */
    snmp_varlist_add_variable(&var_list, mteHotContextName,
                              sizeof(mteHotContextName) / sizeof(oid),
                              ASN_OCTET_STR,
                              (u_char *) item->mteTriggerContextName,
                              item->mteTriggerContextNameLen);

    snmp_varlist_add_variable(&var_list, mteHotOID,
                              sizeof(mteHotOID) / sizeof(oid),
                              ASN_OBJECT_ID, (u_char *) name_oid,
                              sizeof(oid) * name_oid_len);

    if (trap_oid == mteTriggerFailure || trap_oid == mteEventSetFailure) {
        /*
         * mteFailedReason  
         */
        snmp_varlist_add_variable(&var_list, mteFailedReason,
                                  sizeof(mteFailedReason) / sizeof(oid),
                                  ASN_INTEGER, (u_char *) value,
                                  sizeof(value));
    } else {
        /*
         * mteHotValue  
         */
        snmp_varlist_add_variable(&var_list, mteHotValue,
                                  sizeof(mteHotValue) / sizeof(oid),
                                  ASN_INTEGER, (u_char *) value,
                                  sizeof(value));
    }

    /*
     * add in traps from main table 
     */
    mte_add_objects(var_list, item, item->mteTriggerObjectsOwner,
                    item->mteTriggerObjects,
                    name_oid + item->mteTriggerValueIDLen,
                    name_oid_len - item->mteTriggerValueIDLen);
    /*
     * add in traps from sub table 
     */
    mte_add_objects(var_list, item, objowner, objname,
                    name_oid + item->mteTriggerValueIDLen,
                    name_oid_len - item->mteTriggerValueIDLen);

    /*
     * XXX: stuff based on event table 
     */
    DEBUGMSGTL(("mteTriggerTest:send_mte_trap", "sending the trap (%s): ",
                reason));
    DEBUGMSGOID(("mteTriggerTest:send_mte_trap", name_oid, name_oid_len));
    DEBUGMSG(("mteTriggerTest:send_mte_trap", " = %ld\n", *value));

    send_v2trap(var_list);
    snmp_free_varbind(var_list);
}

void
last_state_clean(void *data)
{
    struct last_state *cleanme = (struct last_state *) data;
    SNMP_FREE(cleanme->value);
    SNMP_FREE(cleanme);
}

/*
 * retrieves requested info in pdu from the current target 
 */
netsnmp_pdu    *
mte_get_response(struct mteTriggerTable_data *item, netsnmp_pdu *pdu)
{
    netsnmp_pdu    *response = NULL;
    int             status = 0;
    char            buf[SPRINT_MAX_LEN];

    /*
     * local agent check 
     */
    pdu->errstat = SNMPERR_SUCCESS;
    pdu->errindex = 0;
    pdu->version = item->pdu_version;
    pdu->securityModel = item->pdu_securityModel;
    pdu->securityLevel = item->pdu_securityLevel;
    pdu->tDomain = item->pdu_tDomain;
    pdu->tDomainLen = item->pdu_tDomainLen;
    pdu->transport_data = netsnmp_memdup(item->pdu_transport,
                                         item->pdu_transportLen);
    pdu->transport_data_length = item->pdu_transportLen;
    pdu->community = netsnmp_memdup(item->pdu_community,
                                    item->pdu_community_len);
    pdu->community_len = item->pdu_community_len;
    pdu->contextName = netsnmp_memdup(item->mteTriggerContextName,
                                      item->mteTriggerContextNameLen);
    pdu->contextNameLen = item->mteTriggerContextNameLen;
    pdu->securityName = netsnmp_memdup(item->pdu_securityName,
                                       item->pdu_securityNameLen);
    pdu->securityNameLen = item->pdu_securityNameLen;
    DEBUGMSGTL(("mteTriggerTable",
                "accessing locally with secName \"%s\" community \"%s\"\n",
                item->pdu_securityName ? (char *) item->
                pdu_securityName : "[NIL]",
                item->pdu_community ? (char *) item->
                pdu_community : "[NIL]"));

    if (item->mteTriggerTargetTagLen == 0) {
        /*
         * send to the local agent 
         */

        if (mte_callback_sess == NULL)
            mte_callback_sess =  netsnmp_query_get_default_session();
        if (!mte_callback_sess)
            return NULL;

        status = snmp_synch_response(mte_callback_sess, pdu, &response);

        if (status != SNMP_ERR_NOERROR ||
            response->errstat != SNMP_ERR_NOERROR) {
            /*
             * xxx 
             */
            char           *errstr;
            snmp_error(mte_callback_sess, 0, 0, &errstr);
            if (response) {
                DEBUGMSGTL(("mteTriggerTable",
                            "Error received: status=%d, sess_error=%s, pduerr=%d/%s, pdu version=%d\n",
                            status, errstr,
                            response->errstat,
                            snmp_api_errstring(response->errstat),
                            response->version));
            } else {
                DEBUGMSGTL(("mteTriggerTable",
                            "Error received: status=%d, sess_error=%s [no response pointer]\n",
                            status, errstr));
            }
            if (errstr)
                free(errstr);
            return NULL;        /* XXX: proper failure, trap sent, etc */
        }
    } else {
        /*
         * remote target list 
         */
        /*
         * XXX 
         */
    }
    if (response->variables)
        snprint_variable(buf, sizeof(buf), response->variables->name,
                         response->variables->name_length,
                         response->variables);
    else
        strcpy(buf, "empty");
    buf[sizeof(buf) - 1] = '\0';
    DEBUGMSGTL(("mteTriggerTable", "got a variables: %s\n", buf));
    return response;
}


/*
 * Return 1 if `type' is an integer type; specifically, to quote RFC 2981,
 * p. 13, "anything that ends up encoded for transmission (that is, in BER,
 * not ASN.1) as an integer".  Return 0 for all other types.  
 */

int
mte_is_integer_type(unsigned char type)
{
    switch (type) {
    case ASN_INTEGER:
    case ASN_COUNTER:
    case ASN_GAUGE:
    case ASN_TIMETICKS:
    case ASN_UINTEGER:
    case ASN_COUNTER64:
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
    case ASN_OPAQUE_COUNTER64:
    case ASN_OPAQUE_U64:
    case ASN_OPAQUE_I64:
#endif                          /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
        return 1;
    default:
        return 0;
    }
}


/*
 * Return 0 if the discontinuity object was checked and no discontinuity has
 * occurred, 1 if the discontinuity object was checked and a discontinuity
 * has occurred or -1 if the discontinuity object is not accessible.  
 */

int
mte_discontinuity_occurred(struct mteTriggerTable_data *item)
{
    netsnmp_pdu    *pdu = NULL, *response = NULL;
    unsigned long   discoTicks = 0;     /*  cool var name  */

    if (item->mteTriggerDeltaDiscontinuityIDLen == 0 ||
        (snmp_oid_compare(item->mteTriggerDeltaDiscontinuityID,
                          item->mteTriggerDeltaDiscontinuityIDLen,
                          sysUpTimeInstance,
                          sizeof(sysUpTimeInstance) / sizeof(oid)) == 0)) {
        DEBUGMSGTL(("mte_disco",
                    "discoID either zero-length or sysUpTimeInstance\n"));
    } else {
        if (item->mteTriggerValueIDWildcard == TV_TRUE) {
            pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
        } else {
            pdu = snmp_pdu_create(SNMP_MSG_GET);
        }
        snmp_add_null_var(pdu, item->mteTriggerDeltaDiscontinuityID,
                          item->mteTriggerDeltaDiscontinuityIDLen);
        response = mte_get_response(item, pdu);
        if (response == NULL) {
            /*
             * XXX:  send a mteTriggerFailure notification with the appropriate
             * error code here.  
             */
            /*
             * "If the object identified is not accessible the sample attempt is in 
             * error, with the error code as from an SNMP request."  
             */
            DEBUGMSGTL(("mte_disco", "failure (auth?) getting discoID\n"));
            return -1;
        } else {
            if (item->mteTriggerDeltaDiscontinuityIDType ==
                MTETRIGGERDELTADISCONTINUITYIDTYPE_TIMETICKS ||
                item->mteTriggerDeltaDiscontinuityIDType ==
                MTETRIGGERDELTADISCONTINUITYIDTYPE_TIMESTAMP) {
                if (response->errstat == SNMPERR_SUCCESS) {
                    if (response->variables != NULL &&
                        response->variables->type == ASN_TIMETICKS) {
                        DEBUGMSGTL(("mte_disco",
                                    "got ASN_TIMETICKS-valued variable\n"));
                        discoTicks =
                            *((unsigned long *) response->variables->val.
                              integer);
                        if (item->prevDiscoTicks != 0) {
                            if (discoTicks != item->prevDiscoTicks) {
                                /*
                                 * Danger Will Robinson: there has been a discontinuity!  
                                 */
                                DEBUGMSGTL(("mte_disco",
                                            "a discontinuity has occurred\n"));
                                item->prevDiscoTicks = discoTicks;
                                snmp_free_pdu(response);
                                return 1;
                            }
                        }
                        item->prevDiscoTicks = discoTicks;
                    } else {
                        /*
                         * XXX: send a mteTriggerFailure notification with the
                         * appropriate error code here.  
                         */
                        if (response->variables != NULL &&
                            (response->variables->type == SNMP_NOSUCHOBJECT
                             || response->variables->type ==
                             SNMP_NOSUCHINSTANCE
                             || response->variables->type ==
                             SNMP_ENDOFMIBVIEW)) {
                            /*
                             * noSuchName I guess.  
                             */
                        } else {
                            /*
                             * badType.  
                             */
                        }
                        DEBUGMSGTL(("mte_disco",
                                    "failure getting discoID\n"));
                        snmp_free_pdu(response);
                        return -1;
                    }
                } else {
                    /*
                     * XXX: send a mteTriggerFailure notification with the appropriate
                     * error code (just use response->errstat) here.  
                     */
                    DEBUGMSGTL(("mte_disco", "failure getting discoID\n"));
                    snmp_free_pdu(response);
                    return -1;
                }
            } else {
                /*
                 * Don't handle dateAndTime type queries yet.  
                 */
                DEBUGMSGTL(("mte_disco",
                            "dateAndTime query UNIMPLEMENTED\n"));
            }
            snmp_free_pdu(response);
        }
    }

    /*
     * "...if this object does not point to sysUpTime discontinuity checking
     * MUST still check sysUpTime for an overall discontinuity."  
     */
    if (snmp_oid_compare(item->mteTriggerDeltaDiscontinuityID,
                         item->mteTriggerDeltaDiscontinuityIDLen,
                         sysUpTimeInstance,
                         sizeof(sysUpTimeInstance) / sizeof(oid)) != 0) {
        DEBUGMSGTL(("mte_disco", "discoID != sysUpTimeInstance\n"));
        /*
         * At the moment we only support checking the local system so there's no
         * point doing anything extra here.  
         */
    }

    /*
     * Well if we got all the way to here, then there has been neither a
     * discontinuity nor an error.  
     */
    DEBUGMSGTL(("mte_disco", "no discontinuity\n"));
    return 0;
}


void
mte_run_trigger(unsigned int clientreg, void *clientarg)
{

    struct mteTriggerTable_data *item =
        (struct mteTriggerTable_data *) clientarg;
    netsnmp_pdu    *pdu = NULL, *response = NULL;
    char            buf[SPRINT_MAX_LEN];
    int             msg_type = SNMP_MSG_GET, disco;

    oid            *next_oid;
    size_t          next_oid_len;
    long           *value, *old_value, x;
    struct last_state *laststate;
    char            lastbool = 0, boolresult = 0, lastthresh = 0;

    if (!item) {
        /*
         * ack 
         */
        snmp_alarm_unregister(clientreg);
        return;
    }
    DEBUGMSGTL(("mteTriggertable", "Running trigger for %s/%s\n",
                item->mteOwner, item->mteTriggerName));

    next_oid = item->mteTriggerValueID;
    next_oid_len = item->mteTriggerValueIDLen;
    if (item->mteTriggerValueIDWildcard == TV_TRUE)
        msg_type = SNMP_MSG_GETNEXT;

    item->hc_storage_old = item->hc_storage;
    item->hc_storage = NULL;
    do {
        pdu = snmp_pdu_create(msg_type);
        snmp_add_null_var(pdu, next_oid, next_oid_len);

        if(response)
            snmp_free_pdu(response);
		
        response = mte_get_response(item, pdu);
        if (!response)
            break;              /* XXX: proper failure */

        if (item->mteTriggerValueIDWildcard == TV_TRUE &&
            ((response->variables->type >= SNMP_NOSUCHOBJECT &&
              response->variables->type <= SNMP_ENDOFMIBVIEW) ||
             snmp_oid_compare(item->mteTriggerValueID,
                              item->mteTriggerValueIDLen,
                              response->variables->name,
                              item->mteTriggerValueIDLen) != 0)) {
            DEBUGMSGTL(("mteTriggerTable",
                        "DONE, last varbind processed\n"));
            break;
        }

        /*
         * shorter pointers 
         */
        next_oid = response->variables->name;
        next_oid_len = response->variables->name_length;

        /*
         * Send a "bad type" notification if the type of the target object is 
         * non-INTEGER and the test type is either `boolean' or `threshold'
         * (which want to do arithmetic).  
         */
        if (((item->mteTriggerTest[0] & MTETRIGGERTEST_BOOLEAN) ||
             (item->mteTriggerTest[0] & MTETRIGGERTEST_THRESHOLD)) &&
            response->errstat == SNMPERR_SUCCESS &&
            !mte_is_integer_type(response->variables->type)) {
            long            failure = MTE_FAILURE_BADTYPE;
            send_mte_trap(item, mteTriggerFailure,
                          sizeof(mteTriggerFailure) / sizeof(oid),
                          next_oid, next_oid_len, &failure,
                          NULL, NULL, "failure: bad type");
            /*
             * RFC2981, p.15: "If the value syntax of those objects
             * [returned by a getNext-style match] is not usable, that
             * results in a `badType' error THAT TERMINATES THE SCAN."
             * (my emphasis).  
             */
            break;
        }

        /*
         * Clone the value.  XXX: What happens if it's an unsigned type? Or a
         * 64-bit type, or an OCTET STRING for the sake of argument.  Do
         * everything in 64-bit arithmetic perhaps?  Generate "bad type"
         * notifications for non-INTEGER cases (except for existence).  
         */
        if (response->errstat == SNMPERR_SUCCESS &&
            response->variables->val.integer)
            value = netsnmp_memdup(response->variables->val.integer,
                                   sizeof(*response->variables->val.integer));
        else
            value = NULL;

        snprint_variable(buf, sizeof(buf),
                         next_oid, next_oid_len, response->variables);
        buf[sizeof(buf) - 1] = '\0';
        DEBUGMSGTL(("mteTriggerTable", "received %s (type %d)\n", buf,
                    response->variables->type));

        /*
         * see if we have old values for this 
         */
        laststate = header_complex_get_from_oid(item->hc_storage_old,
                                                next_oid, next_oid_len);
        if (laststate) {
            old_value = laststate->value;
            lastbool = laststate->lastbool;
            lastthresh = laststate->lastthreshold;
        } else {
            old_value = NULL;
            lastthresh = MTE_THRESHOLD_BEGIN;
        }

        /*
         * deal with existence tests 
         */
        if (item->mteTriggerTest[0] & MTETRIGGERTEST_EXISTENCE) {
            if ((item->mteTriggerExistenceTest[0] &
                 MTETRIGGEREXISTENCETEST_PRESENT)
                && value && !old_value &&
                (item->started ||
                 (item->mteTriggerExistenceStartup[0] &
                  MTETRIGGEREXISTENCESTARTUP_PRESENT))) {
                /*
                 * XXX: if mteTriggerExistenceTest is not "present", for
                 * example, and then turned on when has been previously
                 * off, do we respect the value of the last known
                 * existence status? 
                 */
                send_mte_trap(item, mteTriggerFired,
                              sizeof(mteTriggerFired) / sizeof(oid),
                              next_oid, next_oid_len,
                              value, item->mteTriggerExistenceObjectsOwner,
                              item->mteTriggerExistenceObjects,
                              "existence: present");
                run_mte_events(item, next_oid, next_oid_len,
                               item->mteTriggerExistenceEventOwner,
                               item->mteTriggerExistenceEvent);
            }

            if ((item->mteTriggerExistenceTest[0] &
                 MTETRIGGEREXISTENCETEST_CHANGED)
                && value && old_value && *old_value != *value) {
                /*
                 * XXX: if mteTriggerExistenceTest is not "present", for
                 * example, and then turned on when has been previously
                 * off, do we respect the value of the last known
                 * existence status? 
                 */
                send_mte_trap(item, mteTriggerFired,
                              sizeof(mteTriggerFired) / sizeof(oid),
                              next_oid, next_oid_len,
                              value, item->mteTriggerExistenceObjectsOwner,
                              item->mteTriggerExistenceObjects,
                              "existence: changed");
                run_mte_events(item, next_oid, next_oid_len,
                               item->mteTriggerExistenceEventOwner,
                               item->mteTriggerExistenceEvent);
            }
        }

        /*
         * Deal with boolean tests.  
         */
        if ((item->mteTriggerTest[0] & MTETRIGGERTEST_BOOLEAN) &&
            ((item->mteTriggerSampleType ==
              MTETRIGGERSAMPLETYPE_ABSOLUTEVALUE && value)
             || (item->mteTriggerSampleType ==
                 MTETRIGGERSAMPLETYPE_DELTAVALUE && value && old_value))) {
            if (item->mteTriggerSampleType ==
                MTETRIGGERSAMPLETYPE_DELTAVALUE) {
                /*
                 * XXX: Must check the discontinuity OID here.  
                 */
                disco = mte_discontinuity_occurred(item);
                if (disco == -1) {
                    /*
                     * An error notification has already been sent; just bail
                     * out now.  
                     */
                    /*
                     * XXX: should save values here?  
                     */
                    return;
                } else if (disco == 1) {
                    /*
                     * A discontinuity has occurred; the right thing to do here
                     * depends on the exact type.  FOR NOW, assume long.  
                     */
                    x = *((long *) value) + (INT_MAX -
                                             *((long *) old_value));
                } else {
                    x = *((long *) value) - *((long *) old_value);
                }
            } else {
                x = *((long *) value);
            }

            switch (item->mteTriggerBooleanComparison) {
            case MTETRIGGERBOOLEANCOMPARISON_UNEQUAL:
                boolresult = (x != item->mteTriggerBooleanValue);
                break;

            case MTETRIGGERBOOLEANCOMPARISON_EQUAL:
                boolresult = (x == item->mteTriggerBooleanValue);
                break;

            case MTETRIGGERBOOLEANCOMPARISON_LESS:
                boolresult = (x < item->mteTriggerBooleanValue);
                break;

            case MTETRIGGERBOOLEANCOMPARISON_LESSOREQUAL:
                boolresult = (x <= item->mteTriggerBooleanValue);
                break;

            case MTETRIGGERBOOLEANCOMPARISON_GREATER:
                boolresult = (x > item->mteTriggerBooleanValue);
                break;

            case MTETRIGGERBOOLEANCOMPARISON_GREATEROREQUAL:
                boolresult = (x >= item->mteTriggerBooleanValue);
                break;

            default:
                snmp_log(LOG_WARNING,
                         "illegal value in mteTriggerBooleanComparison object: %ld",
                         item->mteTriggerBooleanComparison);
                boolresult = item->lastboolresult;      /* to fail next test */
            }

            if (boolresult &&
                ((item->mteTriggerBooleanStartup ==
                  MTETRIGGERBOOLEANSTARTUP_TRUE
                  && lastbool == (char)-1) || lastbool != boolresult)) {
                send_mte_trap(item, mteTriggerFired,
                              sizeof(mteTriggerFired) / sizeof(oid),
                              next_oid, next_oid_len,
                              &x, item->mteTriggerBooleanObjectsOwner,
                              item->mteTriggerBooleanObjects,
                              "boolean: true");
                run_mte_events(item, next_oid, next_oid_len,
                               item->mteTriggerBooleanEventOwner,
                               item->mteTriggerBooleanEvent);
            }

            DEBUGMSGTL(("mteTriggerTable",
                        "value: %d %ld %lu x: %d %ld %lu\n", *value,
                        *value, *value, x, x, x));

            DEBUGMSGTL(("mteTriggerTable",
                        "boolean result: x=%d %s configured=%d = %d\n",
                        x,
                        se_find_label_in_slist("mteBooleanOperators",
                                               item->
                                               mteTriggerBooleanComparison),
                        item->mteTriggerBooleanValue, boolresult));
        }

        /*
         * Deal with threshold tests.  XXX: doesn't handle "delta-type"
         * sampling.  
         */
        if ((item->mteTriggerTest[0] & MTETRIGGERTEST_THRESHOLD) &&
            ((item->mteTriggerSampleType ==
              MTETRIGGERSAMPLETYPE_ABSOLUTEVALUE && value)
             || (item->mteTriggerSampleType ==
                 MTETRIGGERSAMPLETYPE_DELTAVALUE && value && old_value))) {
            /*
             * XXX: correct intepretation of mteTriggerThresholdStartup? 
             */
            /*
             * only fires when passed and just set to active?  What
             * about a newly discovered node that is past a
             * threshold once we've been active for a turn at least? 
             */
            /*
             * XXX: Check notions of > vs >= 
             */
            if (((item->started == MTE_STARTED && laststate &&
                  lastthresh == MTE_THRESHOLD_LOW) ||
                 (item->started != MTE_STARTED &&
                  (item->mteTriggerThresholdStartup ==
                   MTETRIGGERTHRESHOLDSTARTUP_RISING
                   || item->mteTriggerThresholdStartup ==
                   MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING)))
                && (*value >= item->mteTriggerThresholdRising)) {
                send_mte_trap(item, mteTriggerRising,
                              sizeof(mteTriggerRising) / sizeof(oid),
                              next_oid, next_oid_len, value,
                              item->mteTriggerThresholdObjectsOwner,
                              item->mteTriggerThresholdObjects,
                              "threshold: rising");
                run_mte_events(item, next_oid, next_oid_len,
                               item->mteTriggerThresholdRisingEventOwner,
                               item->mteTriggerThresholdRisingEvent);
            }
            if (((item->started == MTE_STARTED && laststate &&
                  lastthresh == MTE_THRESHOLD_HIGH) ||
                 (item->started != MTE_STARTED &&
                  (item->mteTriggerThresholdStartup ==
                   MTETRIGGERTHRESHOLDSTARTUP_FALLING
                   || item->mteTriggerThresholdStartup ==
                   MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING)))
                && (*value <= item->mteTriggerThresholdFalling)) {
                send_mte_trap(item, mteTriggerFalling,
                              sizeof(mteTriggerFalling) / sizeof(oid),
                              next_oid, next_oid_len, value,
                              item->mteTriggerThresholdObjectsOwner,
                              item->mteTriggerThresholdObjects,
                              "threshold: falling");
                run_mte_events(item, next_oid, next_oid_len,
                               item->mteTriggerThresholdFallingEventOwner,
                               item->mteTriggerThresholdFallingEvent);
            }

        }

        if (value) {
            struct last_state *new_last_state =
                SNMP_MALLOC_STRUCT(last_state);
            new_last_state->value = value;
            new_last_state->lastbool = boolresult;
            header_complex_add_data_by_oid(&item->hc_storage, next_oid,
                                           next_oid_len, new_last_state);

            /*
             * set our notion of the current known threshold state 
             */
            if (lastthresh == MTE_THRESHOLD_LOW &&
                *value >= item->mteTriggerThresholdRising &&
                *value > item->mteTriggerThresholdFalling)
                new_last_state->lastthreshold = MTE_THRESHOLD_HIGH;
            else if (lastthresh == MTE_THRESHOLD_HIGH &&
                     *value < item->mteTriggerThresholdRising &&
                     *value <= item->mteTriggerThresholdFalling)
                new_last_state->lastthreshold = MTE_THRESHOLD_LOW;
            else if (lastthresh == MTE_THRESHOLD_BEGIN) {
                if (*value >= item->mteTriggerThresholdRising)
                    new_last_state->lastthreshold = MTE_THRESHOLD_HIGH;
                else if (*value <= item->mteTriggerThresholdFalling)
                    new_last_state->lastthreshold = MTE_THRESHOLD_LOW;
                /*
                 * XXX: else???  in between?  undefined? 
                 */
            } else {
                new_last_state->lastthreshold = lastthresh;
            }
        }

        /*
         * extract from old hc storage 
         */
        if (laststate) {
            header_complex_extract_entry(&item->hc_storage_old,
                                         header_complex_find_entry(item->
                                                                   hc_storage_old,
                                                                   (void *)
                                                                   laststate));
            last_state_clean(laststate);
        }

    } while (item->mteTriggerValueIDWildcard == TV_TRUE);

    if(response)
        snmp_free_pdu(response);

    /*
     * loop through old values for DNE cases 
     */
    if (item->mteTriggerExistenceTest[0] & MTETRIGGEREXISTENCETEST_ABSENT) {

        struct header_complex_index *iter;

        /*
         * XXX: broken 
         */
        if ((item->mteTriggerExistenceStartup[0] &
             MTETRIGGEREXISTENCESTARTUP_ABSENT)) {
            /*
             * XXX: send trap that nothing was found? 
             */
            /*
             * only if !wild? (see mib)
             */
        }
        for (iter = item->hc_storage_old; iter; iter = iter->next) {
            laststate = (struct last_state *) iter->data;
            send_mte_trap(item, mteTriggerFired,
                          sizeof(mteTriggerFired) / sizeof(oid),
                          iter->name, iter->namelen, laststate->value,
                          item->mteTriggerExistenceObjectsOwner,
                          item->mteTriggerExistenceObjects,
                          "existence: absent");
        }
        header_complex_free_all(item->hc_storage_old, last_state_clean);
        item->hc_storage_old = NULL;
    }

    item->started = MTE_STARTED;
}


/*
 * handling routines 
 */
void
mte_enable_trigger(struct mteTriggerTable_data *item)
{
    if (!item)
        return;

    if (item->alarmreg)
        snmp_alarm_unregister(item->alarmreg);

    if (item->mteTriggerFrequency > 0) {
        DEBUGMSGTL(("mteTriggertable", "Enabling trigger for %s/%s @ %u\n",
                    item->mteOwner, item->mteTriggerName,
                    item->mteTriggerFrequency));
        item->alarmreg =
            snmp_alarm_register(item->mteTriggerFrequency, SA_REPEAT,
                                mte_run_trigger, item);
    }
}

void
mte_disable_trigger(struct mteTriggerTable_data *item)
{
    if (!item)
        return;

    if (item->alarmreg) {
        DEBUGMSGTL(("mteTriggertable", "Disabling trigger for %s/%s\n",
                    item->mteOwner, item->mteTriggerName));
        snmp_alarm_unregister(item->alarmreg);
        item->alarmreg = 0;
    }
    item->started = MTE_NOTSTARTED;
}