开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
mteTriggerTable.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：128k
源码类别：

SNMP编程

开发平台：

Unix_Linux

mteTriggerTable.c：源码内容
  1. /*
  2.  * This file was generated by mib2c and is intended for use as
  3.  * a mib module for the ucd-snmp snmpd agent. 
  4.  */
  7. /*
  8.  * This should always be included first before anything else 
  9.  */
  10. #include <net-snmp/net-snmp-config.h>
  11. #if HAVE_STDLIB_H
  12. #include <stdlib.h>
  13. #endif
  14. #if HAVE_STRING_H
  15. #include <string.h>
  16. #else
  17. #include <strings.h>
  18. #endif
  19. #ifdef HAVE_LIMITS_H
  20. #include <limits.h>
  21. #endif
  24. /*
  25.  * minimal include directives 
  26.  */
  27. #include <net-snmp/net-snmp-includes.h>
  28. #include <net-snmp/agent/net-snmp-agent-includes.h>
  30. #include "header_complex.h"
  31. #include "mteTriggerTable.h"
  32. #include "mteTriggerBooleanTable.h"
  33. #include "mteTriggerDeltaTable.h"
  34. #include "mteTriggerExistenceTable.h"
  35. #include "mteTriggerThresholdTable.h"
  36. #include "mteEventTable.h"
  37. #include "mteObjectsTable.h"
  39. /*
  40.  * mteTriggerTable_variables_oid:
  41.  *   this is the top level oid that we want to register under.  This
  42.  *   is essentially a prefix, with the suffix appearing in the
  43.  *   variable below.
  44.  */
  46. /*
  47.  * trap definitions 
  48.  */
  49. oid             mteTriggerFired[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 1 };
  50. oid             mteTriggerRising[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 2 };
  51. oid             mteTriggerFalling[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 3 };
  52. oid             mteTriggerFailure[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 4 };
  53. oid             mteEventSetFailure[] = { 1, 3, 6, 1, 2, 1, 88, 2, 0, 5 };
  55. /*
  56.  * trap objects 
  57.  */
  58. oid             mteHotTrigger[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 1 };
  59. oid             mteHotTargetName[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 2 };
  60. oid             mteHotContextName[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 3 };
  61. oid             mteHotOID[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 4 };
  62. oid             mteHotValue[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 5 };
  63. oid             mteFailedReason[] = { 1, 3, 6, 1, 2, 1, 88, 2, 1, 6 };
  65. /*
  66.  * For discontinuity checking.  
  67.  */
  68. oid             sysUpTimeInstance[] = { 1, 3, 6, 1, 2, 1, 1, 3, 0 };
  70. oid             mteTriggerTable_variables_oid[] =
  71.     { 1, 3, 6, 1, 2, 1, 88, 1, 2, 2 };
  74. /*
  75.  * variable2 mteTriggerTable_variables:
  76.  *   this variable defines function callbacks and type return information 
  77.  *   for the mteTriggerTable mib section 
  78.  */
  81. struct variable2 mteTriggerTable_variables[] = {
  82.     /*
  83.      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
  84.      */
  85. #define   MTETRIGGERCOMMENT     5
  86.     {MTETRIGGERCOMMENT, ASN_OCTET_STR, RWRITE, var_mteTriggerTable, 2,
  87.      {1, 3}},
  88. #define   MTETRIGGERTEST        6
  89.     {MTETRIGGERTEST, ASN_OCTET_STR, RWRITE, var_mteTriggerTable, 2, {1, 4}},
  90. #define   MTETRIGGERSAMPLETYPE  7
  91.     {MTETRIGGERSAMPLETYPE, ASN_INTEGER, RWRITE, var_mteTriggerTable, 2,
  92.      {1, 5}},
  93. #define   MTETRIGGERVALUEID     8
  94.     {MTETRIGGERVALUEID, ASN_OBJECT_ID, RWRITE, var_mteTriggerTable, 2,
  95.      {1, 6}},
  96. #define   MTETRIGGERVALUEIDWILDCARD  9
  97.     {MTETRIGGERVALUEIDWILDCARD, ASN_INTEGER, RWRITE, var_mteTriggerTable,
  98.      2, {1, 7}},
  99. #define   MTETRIGGERTARGETTAG   10
  100.     {MTETRIGGERTARGETTAG, ASN_OCTET_STR, RWRITE, var_mteTriggerTable, 2,
  101.      {1, 8}},
  102. #define   MTETRIGGERCONTEXTNAME  11
  103.     {MTETRIGGERCONTEXTNAME, ASN_OCTET_STR, RWRITE, var_mteTriggerTable, 2,
  104.      {1, 9}},
  105. #define   MTETRIGGERCONTEXTNAMEWILDCARD  12
  106.     {MTETRIGGERCONTEXTNAMEWILDCARD, ASN_INTEGER, RWRITE,
  107.      var_mteTriggerTable, 2, {1, 10}},
  108. #define   MTETRIGGERFREQUENCY   13
  109.     {MTETRIGGERFREQUENCY, ASN_UNSIGNED, RWRITE, var_mteTriggerTable, 2,
  110.      {1, 11}},
  111. #define   MTETRIGGEROBJECTSOWNER  14
  112.     {MTETRIGGEROBJECTSOWNER, ASN_OCTET_STR, RWRITE, var_mteTriggerTable, 2,
  113.      {1, 12}},
  114. #define   MTETRIGGEROBJECTS     15
  115.     {MTETRIGGEROBJECTS, ASN_OCTET_STR, RWRITE, var_mteTriggerTable, 2,
  116.      {1, 13}},
  117. #define   MTETRIGGERENABLED     16
  118.     {MTETRIGGERENABLED, ASN_INTEGER, RWRITE, var_mteTriggerTable, 2,
  119.      {1, 14}},
  120. #define   MTETRIGGERENTRYSTATUS  17
  121.     {MTETRIGGERENTRYSTATUS, ASN_INTEGER, RWRITE, var_mteTriggerTable, 2,
  122.      {1, 15}},
  124. };
  125. /*
  126.  * (L = length of the oidsuffix) 
  127.  */
  130. /*
  131.  * global storage of our data, saved in and configured by header_complex() 
  132.  */
  133. struct header_complex_index *mteTriggerTableStorage = NULL;
  135. netsnmp_session *mte_callback_sess = NULL;
  136. extern int      callback_master_num;
  138. /*
  139.  * init_mteTriggerTable():
  140.  *   Initialization routine.  This is called when the agent starts up.
  141.  *   At a minimum, registration of your variables should take place here.
  142.  */
  143. void
  144. init_mteTriggerTable(void)
  145. {
  146.     DEBUGMSGTL(("mteTriggerTable", "initializing...  "));
  148. #ifndef SNMP_TRANSPORT_CALLBACK_DOMAIN
  149.     snmp_log(LOG_WARNING,"mteTriggerTable has been disabled because "
  150.                "the callback transport is not available.n");
  151.     return;
  152. #endif
  154.     /*
  155.      * register ourselves with the agent to handle our mib tree 
  156.      */
  157.     REGISTER_MIB("mteTriggerTable", mteTriggerTable_variables, variable2,
  158.                  mteTriggerTable_variables_oid);
  161.     /*
  162.      * register our config handler(s) to deal with registrations 
  163.      */
  164.     snmpd_register_config_handler("mteTriggerTable", parse_mteTriggerTable,
  165.                                   NULL, NULL);
  167.     snmpd_register_config_handler("monitor", parse_simple_monitor, NULL,
  168.                                   "[options] monitor_expression [see "man snmpd.conf"]");
  169.     snmpd_register_config_handler("defaultMonitors",
  170.                                   parse_default_monitors, NULL, "yes|no");
  171.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmpd", "agentSecName",
  172.                        NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_SECNAME);
  174.     /*
  175.      * we need to be called back later to store our data 
  176.      */
  177.     snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  178.                            store_mteTriggerTable, NULL);
  181.     /*
  182.      * place any other initialization junk you need here 
  183.      */
  184.     se_add_pair_to_slist("mteBooleanOperators", strdup("!="),
  185.                          MTETRIGGERBOOLEANCOMPARISON_UNEQUAL);
  186.     se_add_pair_to_slist("mteBooleanOperators", strdup("=="),
  187.                          MTETRIGGERBOOLEANCOMPARISON_EQUAL);
  188.     se_add_pair_to_slist("mteBooleanOperators", strdup("<"),
  189.                          MTETRIGGERBOOLEANCOMPARISON_LESS);
  190.     se_add_pair_to_slist("mteBooleanOperators", strdup("<="),
  191.                          MTETRIGGERBOOLEANCOMPARISON_LESSOREQUAL);
  192.     se_add_pair_to_slist("mteBooleanOperators", strdup(">"),
  193.                          MTETRIGGERBOOLEANCOMPARISON_GREATER);
  194.     se_add_pair_to_slist("mteBooleanOperators", strdup(">="),
  195.                          MTETRIGGERBOOLEANCOMPARISON_GREATEROREQUAL);
  197. #ifdef SNMP_TRANSPORT_CALLBACK_DOMAIN
  198.     /*
  199.      * open a 'callback' session to the main agent 
  200.      */
  201.     if (mte_callback_sess == NULL) {
  202.         mte_callback_sess = netsnmp_callback_open(callback_master_num,
  203.                                                   NULL, NULL, NULL);
  204.         DEBUGMSGTL(("mteTriggerTable", "created callback session = %08xn",
  205.                     mte_callback_sess));
  206.     }
  207. #endif
  208.     DEBUGMSGTL(("mteTriggerTable", "done.n"));
  209. }
  211. struct mteTriggerTable_data *
  212. create_mteTriggerTable_data(void)
  213. {
  214.     struct mteTriggerTable_data *StorageNew;
  216.     StorageNew = SNMP_MALLOC_STRUCT(mteTriggerTable_data);
  218.     /*
  219.      * fill in default row values here into StorageNew 
  220.      */
  221.     /*
  222.      * fill in values for all tables (even if not
  223.      * appropriate), since its easier to do here than anywhere
  224.      * else 
  225.      */
  226.     StorageNew->mteTriggerComment = strdup("");
  227.     StorageNew->mteTriggerTest = strdup("");
  228.     StorageNew->mteTriggerTest[0] |= (char) MTETRIGGERTEST_BOOLEAN;
  229.     StorageNew->mteTriggerTestLen = 1;
  230.     StorageNew->mteTriggerSampleType = MTETRIGGERSAMPLETYPE_ABSOLUTEVALUE;
  231.     StorageNew->mteTriggerValueID = calloc(1, sizeof(oid) * sizeof(2)); /* 0.0 */
  232.     StorageNew->mteTriggerValueIDLen = 2;
  233.     StorageNew->mteTriggerValueIDWildcard =
  234.         MTETRIGGERVALUEIDWILDCARD_FALSE;
  235.     StorageNew->mteTriggerTargetTag = strdup("");
  236.     StorageNew->mteTriggerContextName = strdup("");
  237.     StorageNew->mteTriggerContextNameWildcard =
  238.         MTETRIGGERCONTEXTNAMEWILDCARD_FALSE;
  239.     StorageNew->mteTriggerFrequency = 600;
  240.     StorageNew->mteTriggerObjectsOwner = strdup("");
  241.     StorageNew->mteTriggerObjects = strdup("");
  242.     StorageNew->mteTriggerEnabled = MTETRIGGERENABLED_FALSE;
  243.     memdup((unsigned char **)
  244.            &(StorageNew->mteTriggerDeltaDiscontinuityID),
  245.            (unsigned char *) sysUpTimeInstance, sizeof(sysUpTimeInstance));
  246.     StorageNew->mteTriggerDeltaDiscontinuityIDLen =
  247.         sizeof(sysUpTimeInstance) / sizeof(oid);
  248.     StorageNew->mteTriggerDeltaDiscontinuityIDWildcard = TV_FALSE;
  249.     StorageNew->mteTriggerDeltaDiscontinuityIDType =
  250.         MTETRIGGERDELTADISCONTINUITYIDTYPE_TIMETICKS;
  251.     StorageNew->mteTriggerExistenceTest = strdup("");
  252.     StorageNew->mteTriggerExistenceTest[0] =
  253.         (char) (MTETRIGGEREXISTENCETEST_PRESENT |
  254.                 MTETRIGGEREXISTENCETEST_ABSENT);
  255.     StorageNew->mteTriggerExistenceTestLen = 1;
  256.     StorageNew->mteTriggerExistenceStartup = strdup("");
  257.     StorageNew->mteTriggerExistenceStartup[0] =
  258.         (char) (MTETRIGGEREXISTENCESTARTUP_PRESENT);
  259.     StorageNew->mteTriggerExistenceStartupLen = 1;
  260.     StorageNew->mteTriggerExistenceObjectsOwner = strdup("");
  261.     StorageNew->mteTriggerExistenceObjects = strdup("");
  262.     StorageNew->mteTriggerExistenceEventOwner = strdup("");
  263.     StorageNew->mteTriggerExistenceEvent = strdup("");
  264.     StorageNew->mteTriggerBooleanComparison =
  265.         MTETRIGGERBOOLEANCOMPARISON_UNEQUAL;
  266.     StorageNew->mteTriggerBooleanStartup = MTETRIGGERBOOLEANSTARTUP_TRUE;
  267.     StorageNew->mteTriggerBooleanObjectsOwner = strdup("");
  268.     StorageNew->mteTriggerBooleanObjects = strdup("");
  269.     StorageNew->mteTriggerBooleanEventOwner = strdup("");
  270.     StorageNew->mteTriggerBooleanEvent = strdup("");
  271.     StorageNew->mteTriggerThresholdStartup =
  272.         MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING;
  273.     StorageNew->mteTriggerThresholdObjectsOwner = strdup("");
  274.     StorageNew->mteTriggerThresholdObjects = strdup("");
  275.     StorageNew->mteTriggerThresholdRisingEventOwner = strdup("");
  276.     StorageNew->mteTriggerThresholdRisingEvent = strdup("");
  277.     StorageNew->mteTriggerThresholdFallingEventOwner = strdup("");
  278.     StorageNew->mteTriggerThresholdFallingEvent = strdup("");
  279.     StorageNew->mteTriggerThresholdDeltaRisingEventOwner = strdup("");
  280.     StorageNew->mteTriggerThresholdDeltaRisingEvent = strdup("");
  281.     StorageNew->mteTriggerThresholdDeltaFallingEventOwner = strdup("");
  282.     StorageNew->mteTriggerThresholdDeltaFallingEvent = strdup("");
  283.     StorageNew->lastboolresult = -1;
  284.     StorageNew->storageType = ST_NONVOLATILE;
  285.     StorageNew->prevDiscoTicks = 0;
  286.     StorageNew->prevUptimeTicks = 0;
  287.     return StorageNew;
  288. }
  290. /*
  291.  * mteTriggerTable_add(): adds a structure node to our data set 
  292.  */
  293. int
  294. mteTriggerTable_add(struct mteTriggerTable_data *thedata)
  295. {
  296.     netsnmp_variable_list *vars = NULL;
  299.     DEBUGMSGTL(("mteTriggerTable", "adding data...  "));
  300.     /*
  301.      * add the index variables to the varbind list, which is 
  302.      * used by header_complex to index the data 
  303.      */
  306.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->mteOwner, thedata->mteOwnerLen); /* mteOwner */
  307.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, (char *) thedata->mteTriggerName, thedata->mteTriggerNameLen);        /* mteTriggerName */
  311.     header_complex_add_data(&mteTriggerTableStorage, vars, thedata);
  312.     DEBUGMSGTL(("mteTriggerTable", "registered an entryn"));
  315.     DEBUGMSGTL(("mteTriggerTable", "done.n"));
  316.     return SNMPERR_SUCCESS;
  317. }
  320. #define MTE_PROCESS_LINE(line) 
  321.   snprintf(buf, SPRINT_MAX_LEN, "-u %s %s", mte_default_user, line); 
  322.   parse_simple_monitor("monitor", buf);
  324. void
  325. parse_default_monitors(const char *token, char *line)
  326. {
  327.     char            buf[SPRINT_MAX_LEN];
  328.     char           *mte_default_user =
  329.         netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_SECNAME);
  331.     if (strncmp(line, "yes", 3) == 0) {
  333.         DEBUGMSGTL(("mteTriggerTable", "registering default monitorsn"));
  335.         if (mte_default_user == NULL) {
  336.             config_perror
  337.                 ("You must specify a user name first using the agentSecName tokenn");
  338.             return;
  339.         }
  341.         /*
  342.          * we don't include many additional objects here as most of
  343.          * the error messages are complete with the needed
  344.          * information 
  345.          */
  346.         MTE_PROCESS_LINE
  347.             ("-o prNames -o prErrMessage "process table" prErrorFlag != 0");
  348.         MTE_PROCESS_LINE
  349.             ("-o memErrorName -o memSwapErrorMsg "memory" memSwapError != 0");
  350.         MTE_PROCESS_LINE
  351.             ("-o extNames -o extOutput "extTable" extResult != 0");
  352.         MTE_PROCESS_LINE
  353.             ("-o dskPath -o dskErrorMsg "dskTable" dskErrorFlag != 0");
  354.         MTE_PROCESS_LINE
  355.             ("-o laNames -o laErrMessage  "laTable" laErrorFlag != 0");
  356.         MTE_PROCESS_LINE
  357.             ("-o fileName -o fileErrorMsg  "fileTable" fileErrorFlag != 0");
  358.         /*
  359.          * this one is not *all* that useful, because the error is
  360.          * only kept for 30 seconds at most.  Maybe scan it every 30
  361.          * seconds, but I'm not doing so without seeking other peoples
  362.          * opinions first. 
  363.          */
  364.         MTE_PROCESS_LINE
  365.             ("-o snmperrErrMessage  "snmperrs" snmperrErrorFlag != 0");
  366.     }
  367. }
  369. static int      monitor_call_count = 0;
  370. void
  371. parse_simple_monitor(const char *token, char *line)
  372. {
  373.     char            buf[SPRINT_MAX_LEN], *cp, ebuf[SPRINT_MAX_LEN],
  374.                     eventname[64];
  375.     oid             obuf[MAX_OID_LEN];
  376.     size_t          obufLen;
  377.     struct mteTriggerTable_data *StorageNew;
  379.     monitor_call_count++;
  380.     eventname[0] = '';
  382.     StorageNew = create_mteTriggerTable_data();
  383.     StorageNew->storageType = ST_READONLY;
  384.     StorageNew->mteTriggerEnabled = MTETRIGGERENABLED_TRUE;
  385.     StorageNew->mteTriggerEntryStatus = RS_ACTIVE;
  386.     StorageNew->mteTriggerValueIDWildcard = MTETRIGGERVALUEIDWILDCARD_TRUE;
  387.     StorageNew->mteTriggerBooleanStartup = MTETRIGGERBOOLEANSTARTUP_TRUE;
  388.     StorageNew->mteTriggerThresholdStartup =
  389.         MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING;
  390.     StorageNew->mteTriggerExistenceTest[0] = 0;
  392.     /*
  393.      * owner = snmpd.conf, why not? 
  394.      */
  395.     StorageNew->mteOwner = strdup("snmpd.conf");
  396.     StorageNew->mteOwnerLen = strlen(StorageNew->mteOwner);
  397.     StorageNew->pdu_version = SNMP_VERSION_3;
  398.     StorageNew->pdu_securityModel = SNMP_SEC_MODEL_USM;
  399.     StorageNew->pdu_securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
  401.     cp = line;
  403.     while (cp && *cp == '-') {
  404.         cp = copy_nword(cp, buf, sizeof(buf));
  405.         switch (buf[1]) {
  406.         case 't':
  407.            /*
  408.             * Threshold toggle
  409.             */
  410.            StorageNew->mteTriggerTest[0] = MTETRIGGERTEST_THRESHOLD;
  411.            break;
  412.         case 'i':
  413.            /*
  414.             * Single instance
  415.             */
  416.            StorageNew->mteTriggerValueIDWildcard = MTETRIGGERVALUEIDWILDCARD_FALSE;
  417.            break;
  418.         case 'r':
  419.             if (cp) {
  420.                 cp = copy_nword(cp, buf, sizeof(buf));
  421.                 StorageNew->mteTriggerFrequency = strtoul(buf, NULL, 0);
  422.             } else {
  423.                 config_perror("No parameter after -r givenn");
  424.                 /*
  425.                  * XXX: free StorageNew 
  426.                  */
  427.                 return;
  428.             }
  429.             break;
  430.         case 'u':
  431.             if (cp) {
  432.                 cp = copy_nword(cp, buf, sizeof(buf));
  433.                 StorageNew->pdu_securityName = strdup(buf);
  434.                 StorageNew->pdu_securityNameLen = strlen(buf);
  435.             } else {
  436.                 config_perror("No parameter after -u givenn");
  437.                 /*
  438.                  * XXX: free StorageNew 
  439.                  */
  440.                 return;
  441.             }
  442.             break;
  443.         case 'e':
  444.             if (cp) {
  445.                 cp = copy_nword(cp, eventname, sizeof(eventname));
  446.             } else {
  447.                 config_perror("No parameter after -e givenn");
  448.                 /*
  449.                  * XXX: free StorageNew 
  450.                  */
  451.                 return;
  452.             }
  453.             break;
  454.         case 'o':
  455.             /*
  456.              * oid 
  457.              */
  458.             cp = copy_nword(cp, buf, sizeof(buf));
  459.             obufLen = MAX_OID_LEN;
  460.             if (!snmp_parse_oid(buf, obuf, &obufLen)) {
  461.                 sprintf(ebuf, "unable to parse oid: %s", buf);
  462.                 config_perror(ebuf);
  463.                 /*
  464.                  * XXX: free StorageNew 
  465.                  */
  466.                 return;
  467.             }
  468.             sprintf(buf, "snmpd.conf%d", monitor_call_count);
  469.             mte_add_object_to_table("snmpd.conf", buf, obuf, obufLen, 1);
  471.             if (StorageNew->mteTriggerObjectsOwnerLen == 0) {
  472.                 SNMP_FREE(StorageNew->mteTriggerObjectsOwner);
  473.                 StorageNew->mteTriggerObjectsOwner = strdup("snmpd.conf");
  474.                 StorageNew->mteTriggerObjectsOwnerLen =
  475.                     strlen("snmpd.conf");
  476.             }
  478.             if (StorageNew->mteTriggerObjectsLen == 0) {
  479.                 SNMP_FREE(StorageNew->mteTriggerObjects);
  480.                 StorageNew->mteTriggerObjects = strdup(buf);
  481.                 StorageNew->mteTriggerObjectsLen = strlen(buf);
  482.             }
  483.             break;
  484.         }
  485.     }
  487.     if (StorageNew->pdu_securityNameLen == 0) {
  488.         char           *mte_default_user =
  489.             netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_INTERNAL_SECNAME);
  490.         if (mte_default_user) {
  491.             StorageNew->pdu_securityName = strdup(mte_default_user);
  492.             StorageNew->pdu_securityNameLen = strlen(mte_default_user);
  493.         } else {
  494.             config_perror("-u USER parameter requiredn");
  495.             /*
  496.              * XXX: free StorageNew 
  497.              */
  498.             return;
  499.         }
  500.     }
  502.     /*
  503.      * name 
  504.      */
  505.     cp = copy_nword(cp, buf, sizeof(buf));
  506.     if (!cp) {
  507.         config_perror("illegal monitor: no name specified");
  508.         /*
  509.          * XXX: free StorageNew 
  510.          */
  511.         return;
  512.     }
  514.     StorageNew->mteTriggerName = strdup(buf);
  515.     StorageNew->mteTriggerNameLen = strlen(StorageNew->mteTriggerName);
  517.     /*
  518.      * oid 
  519.      */
  520.     cp = copy_nword(cp, buf, sizeof(buf));
  521.     obufLen = MAX_OID_LEN;
  522.     if (!snmp_parse_oid(buf, obuf, &obufLen)) {
  523.         sprintf(ebuf, "unable to parse oid: %s", buf);
  524.         config_perror(ebuf);
  525.         /*
  526.          * XXX: free StorageNew 
  527.          */
  528.         return;
  529.     }
  530.     if (StorageNew->mteTriggerValueID)
  531.         free(StorageNew->mteTriggerValueID);
  532.     StorageNew->mteTriggerValueID = snmp_duplicate_objid(obuf, obufLen);
  533.     StorageNew->mteTriggerValueIDLen = obufLen;
  535.     if (StorageNew->mteTriggerTest[0] == MTETRIGGERTEST_THRESHOLD) {
  536.        /*
  537.         * it's a threshold
  538.         * grab 'low' and 'high' params
  539.         */
  540.         if (!cp) {
  541.             config_perror("no lower threshold value specified");
  542.        }
  543.        cp = copy_nword(cp, buf, sizeof(buf));
  544.        StorageNew->mteTriggerThresholdFalling = strtol(buf, NULL, 0);
  546.         if (!cp) {
  547.             config_perror("no upper threshold value specified");
  548.        }
  549.        cp = copy_nword(cp, buf, sizeof(buf));
  550.        StorageNew->mteTriggerThresholdRising = strtol(buf, NULL, 0);
  551.     } else {
  552.         /*
  553.          * if nothing beyond here, it's an existence test 
  554.          */
  555.         if (!cp) {
  556.             StorageNew->mteTriggerTest[0] = (u_char)MTETRIGGERTEST_EXISTENCE;
  557.             if (eventname[0] != '') {
  558.                 StorageNew->mteTriggerExistenceEventOwner =
  559.                     strdup("snmpd.conf");
  560.                 StorageNew->mteTriggerExistenceEventOwnerLen =
  561.                     strlen(StorageNew->mteTriggerExistenceEventOwner);
  562.                 StorageNew->mteTriggerExistenceEvent =
  563.                     strdup(eventname);
  564.                 StorageNew->mteTriggerExistenceEventLen =
  565.                     strlen(eventname);
  566.             }
  567.             mteTriggerTable_add(StorageNew);
  568.             return;
  569.         }
  571.         /*
  572.          * assume boolean (need to deal with threshold statements) 
  573.          */
  574.         cp = copy_nword(cp, buf, sizeof(buf));
  575.         if ((StorageNew->mteTriggerBooleanComparison =
  576.              se_find_value_in_slist("mteBooleanOperators", buf)) == -1) {
  577.             config_perror("illegal boolean operator");
  578.             return;
  579.         }
  581.         /*
  582.          * XXX: add threshold 
  583.          */
  584.         StorageNew->mteTriggerTest[0] = MTETRIGGERTEST_BOOLEAN;
  585.         if (!cp) {
  586.             config_perror("no comparison value specified");
  587.             /*
  588.              * XXX: free StorageNew 
  589.              */
  590.             return;
  591.         }
  593.         cp = copy_nword(cp, buf, sizeof(buf));
  594.         StorageNew->mteTriggerBooleanValue = strtol(buf, NULL, 0);
  596.         if (eventname[0] != '') {
  597.             StorageNew->mteTriggerBooleanEventOwner =
  598.                 strdup("snmpd.conf");
  599.             StorageNew->mteTriggerBooleanEventOwnerLen =
  600.                 strlen(StorageNew->mteTriggerBooleanEventOwner);
  601.             StorageNew->mteTriggerBooleanEvent =
  602.                 strdup(eventname);
  603.             StorageNew->mteTriggerBooleanEventLen =
  604.                 strlen(eventname);
  605.         }
  606.     }
  607.     mteTriggerTable_add(StorageNew);
  608.     mte_enable_trigger(StorageNew);
  610.     DEBUGMSGTL(("mteTriggerTable", "added simple monitor: %sn",
  611.                 StorageNew->mteTriggerName));
  612. }
  615. /*
  616.  * parse_mteTriggerTable():
  617.  *   parses .conf file entries needed to configure the mib.
  618.  */
  619. void
  620. parse_mteTriggerTable(const char *token, char *line)
  621. {
  622.     size_t          tmpint;
  623.     oid            *tmpoid = NULL;
  624.     struct mteTriggerTable_data *StorageTmp =
  625.         SNMP_MALLOC_STRUCT(mteTriggerTable_data);
  627.     DEBUGMSGTL(("mteTriggerTable", "parsing config...  "));
  629.     if (StorageTmp == NULL) {
  630.         config_perror("malloc failure");
  631.         return;
  632.     }
  634.     line =
  635.         read_config_read_data(ASN_OCTET_STR, line, &StorageTmp->mteOwner,
  636.                               &StorageTmp->mteOwnerLen);
  637.     if (StorageTmp->mteOwner == NULL) {
  638.         config_perror("invalid specification for mteOwner");
  639.         return;
  640.     }
  642.     line =
  643.         read_config_read_data(ASN_OCTET_STR, line,
  644.                               &StorageTmp->mteTriggerName,
  645.                               &StorageTmp->mteTriggerNameLen);
  646.     if (StorageTmp->mteTriggerName == NULL) {
  647.         config_perror("invalid specification for mteTriggerName");
  648.         return;
  649.     }
  651.     line =
  652.         read_config_read_data(ASN_OCTET_STR, line,
  653.                               &StorageTmp->mteTriggerComment,
  654.                               &StorageTmp->mteTriggerCommentLen);
  655.     if (StorageTmp->mteTriggerComment == NULL) {
  656.         config_perror("invalid specification for mteTriggerComment");
  657.         return;
  658.     }
  660.     line =
  661.         read_config_read_data(ASN_OCTET_STR, line,
  662.                               &StorageTmp->mteTriggerTest,
  663.                               &StorageTmp->mteTriggerTestLen);
  664.     if (StorageTmp->mteTriggerTest == NULL) {
  665.         config_perror("invalid specification for mteTriggerTest");
  666.         return;
  667.     }
  669.     line =
  670.         read_config_read_data(ASN_INTEGER, line,
  671.                               &StorageTmp->mteTriggerSampleType, &tmpint);
  673.     line =
  674.         read_config_read_data(ASN_OBJECT_ID, line,
  675.                               &StorageTmp->mteTriggerValueID,
  676.                               &StorageTmp->mteTriggerValueIDLen);
  677.     if (StorageTmp->mteTriggerValueID == NULL) {
  678.         config_perror("invalid specification for mteTriggerValueID");
  679.         return;
  680.     }
  682.     line =
  683.         read_config_read_data(ASN_INTEGER, line,
  684.                               &StorageTmp->mteTriggerValueIDWildcard,
  685.                               &tmpint);
  687.     line =
  688.         read_config_read_data(ASN_OCTET_STR, line,
  689.                               &StorageTmp->mteTriggerTargetTag,
  690.                               &StorageTmp->mteTriggerTargetTagLen);
  691.     if (StorageTmp->mteTriggerTargetTag == NULL) {
  692.         config_perror("invalid specification for mteTriggerTargetTag");
  693.         return;
  694.     }
  696.     line =
  697.         read_config_read_data(ASN_OCTET_STR, line,
  698.                               &StorageTmp->mteTriggerContextName,
  699.                               &StorageTmp->mteTriggerContextNameLen);
  700.     if (StorageTmp->mteTriggerContextName == NULL) {
  701.         config_perror("invalid specification for mteTriggerContextName");
  702.         return;
  703.     }
  705.     line =
  706.         read_config_read_data(ASN_INTEGER, line,
  707.                               &StorageTmp->mteTriggerContextNameWildcard,
  708.                               &tmpint);
  710.     line =
  711.         read_config_read_data(ASN_UNSIGNED, line,
  712.                               &StorageTmp->mteTriggerFrequency, &tmpint);
  714.     line =
  715.         read_config_read_data(ASN_OCTET_STR, line,
  716.                               &StorageTmp->mteTriggerObjectsOwner,
  717.                               &StorageTmp->mteTriggerObjectsOwnerLen);
  718.     if (StorageTmp->mteTriggerObjectsOwner == NULL) {
  719.         config_perror("invalid specification for mteTriggerObjectsOwner");
  720.         return;
  721.     }
  723.     line =
  724.         read_config_read_data(ASN_OCTET_STR, line,
  725.                               &StorageTmp->mteTriggerObjects,
  726.                               &StorageTmp->mteTriggerObjectsLen);
  727.     if (StorageTmp->mteTriggerObjects == NULL) {
  728.         config_perror("invalid specification for mteTriggerObjects");
  729.         return;
  730.     }
  732.     line =
  733.         read_config_read_data(ASN_INTEGER, line,
  734.                               &StorageTmp->mteTriggerEnabled, &tmpint);
  736.     line =
  737.         read_config_read_data(ASN_INTEGER, line,
  738.                               &StorageTmp->mteTriggerEntryStatus, &tmpint);
  740.     /*
  741.      * delta table 
  742.      */
  743.     line =
  744.         read_config_read_data(ASN_OBJECT_ID, line,
  745.                               &StorageTmp->mteTriggerDeltaDiscontinuityID,
  746.                               &StorageTmp->
  747.                               mteTriggerDeltaDiscontinuityIDLen);
  748.     if (StorageTmp->mteTriggerDeltaDiscontinuityID == NULL) {
  749.         config_perror
  750.             ("invalid specification for mteTriggerDeltaDiscontinuityID");
  751.         return;
  752.     }
  754.     line =
  755.         read_config_read_data(ASN_INTEGER, line,
  756.                               &StorageTmp->
  757.                               mteTriggerDeltaDiscontinuityIDWildcard,
  758.                               &tmpint);
  760.     line =
  761.         read_config_read_data(ASN_INTEGER, line,
  762.                               &StorageTmp->
  763.                               mteTriggerDeltaDiscontinuityIDType, &tmpint);
  765.     /*
  766.      * existence table 
  767.      */
  768.     line =
  769.         read_config_read_data(ASN_OCTET_STR, line,
  770.                               &StorageTmp->mteTriggerExistenceTest,
  771.                               &StorageTmp->mteTriggerExistenceTestLen);
  772.     if (StorageTmp->mteTriggerExistenceTest == NULL) {
  773.         config_perror("invalid specification for mteTriggerExistenceTest");
  774.         return;
  775.     }
  777.     line =
  778.         read_config_read_data(ASN_OCTET_STR, line,
  779.                               &StorageTmp->mteTriggerExistenceStartup,
  780.                               &StorageTmp->mteTriggerExistenceStartupLen);
  781.     if (StorageTmp->mteTriggerExistenceStartup == NULL) {
  782.         config_perror
  783.             ("invalid specification for mteTriggerExistenceStartup");
  784.         return;
  785.     }
  787.     line =
  788.         read_config_read_data(ASN_OCTET_STR, line,
  789.                               &StorageTmp->mteTriggerExistenceObjectsOwner,
  790.                               &StorageTmp->
  791.                               mteTriggerExistenceObjectsOwnerLen);
  792.     if (StorageTmp->mteTriggerExistenceObjectsOwner == NULL) {
  793.         config_perror
  794.             ("invalid specification for mteTriggerExistenceObjectsOwner");
  795.         return;
  796.     }
  798.     line =
  799.         read_config_read_data(ASN_OCTET_STR, line,
  800.                               &StorageTmp->mteTriggerExistenceObjects,
  801.                               &StorageTmp->mteTriggerExistenceObjectsLen);
  802.     if (StorageTmp->mteTriggerExistenceObjects == NULL) {
  803.         config_perror
  804.             ("invalid specification for mteTriggerExistenceObjects");
  805.         return;
  806.     }
  808.     line =
  809.         read_config_read_data(ASN_OCTET_STR, line,
  810.                               &StorageTmp->mteTriggerExistenceEventOwner,
  811.                               &StorageTmp->
  812.                               mteTriggerExistenceEventOwnerLen);
  813.     if (StorageTmp->mteTriggerExistenceEventOwner == NULL) {
  814.         config_perror
  815.             ("invalid specification for mteTriggerExistenceEventOwner");
  816.         return;
  817.     }
  819.     line =
  820.         read_config_read_data(ASN_OCTET_STR, line,
  821.                               &StorageTmp->mteTriggerExistenceEvent,
  822.                               &StorageTmp->mteTriggerExistenceEventLen);
  823.     if (StorageTmp->mteTriggerExistenceEvent == NULL) {
  824.         config_perror
  825.             ("invalid specification for mteTriggerExistenceEvent");
  826.         return;
  827.     }
  829.     /*
  830.      * boolean table 
  831.      */
  832.     line =
  833.         read_config_read_data(ASN_INTEGER, line,
  834.                               &StorageTmp->mteTriggerBooleanComparison,
  835.                               &tmpint);
  837.     line =
  838.         read_config_read_data(ASN_INTEGER, line,
  839.                               &StorageTmp->mteTriggerBooleanValue,
  840.                               &tmpint);
  842.     line =
  843.         read_config_read_data(ASN_INTEGER, line,
  844.                               &StorageTmp->mteTriggerBooleanStartup,
  845.                               &tmpint);
  847.     line =
  848.         read_config_read_data(ASN_OCTET_STR, line,
  849.                               &StorageTmp->mteTriggerBooleanObjectsOwner,
  850.                               &StorageTmp->
  851.                               mteTriggerBooleanObjectsOwnerLen);
  852.     if (StorageTmp->mteTriggerBooleanObjectsOwner == NULL) {
  853.         config_perror
  854.             ("invalid specification for mteTriggerBooleanObjectsOwner");
  855.         return;
  856.     }
  858.     line =
  859.         read_config_read_data(ASN_OCTET_STR, line,
  860.                               &StorageTmp->mteTriggerBooleanObjects,
  861.                               &StorageTmp->mteTriggerBooleanObjectsLen);
  862.     if (StorageTmp->mteTriggerBooleanObjects == NULL) {
  863.         config_perror
  864.             ("invalid specification for mteTriggerBooleanObjects");
  865.         return;
  866.     }
  868.     line =
  869.         read_config_read_data(ASN_OCTET_STR, line,
  870.                               &StorageTmp->mteTriggerBooleanEventOwner,
  871.                               &StorageTmp->mteTriggerBooleanEventOwnerLen);
  872.     if (StorageTmp->mteTriggerBooleanEventOwner == NULL) {
  873.         config_perror
  874.             ("invalid specification for mteTriggerBooleanEventOwner");
  875.         return;
  876.     }
  878.     line =
  879.         read_config_read_data(ASN_OCTET_STR, line,
  880.                               &StorageTmp->mteTriggerBooleanEvent,
  881.                               &StorageTmp->mteTriggerBooleanEventLen);
  882.     if (StorageTmp->mteTriggerBooleanEvent == NULL) {
  883.         config_perror("invalid specification for mteTriggerBooleanEvent");
  884.         return;
  885.     }
  887.     /*
  888.      * threshold table 
  889.      */
  890.     line =
  891.         read_config_read_data(ASN_INTEGER, line,
  892.                               &StorageTmp->mteTriggerThresholdStartup,
  893.                               &tmpint);
  895.     line =
  896.         read_config_read_data(ASN_INTEGER, line,
  897.                               &StorageTmp->mteTriggerThresholdRising,
  898.                               &tmpint);
  900.     line =
  901.         read_config_read_data(ASN_INTEGER, line,
  902.                               &StorageTmp->mteTriggerThresholdFalling,
  903.                               &tmpint);
  905.     line =
  906.         read_config_read_data(ASN_INTEGER, line,
  907.                               &StorageTmp->mteTriggerThresholdDeltaRising,
  908.                               &tmpint);
  910.     line =
  911.         read_config_read_data(ASN_INTEGER, line,
  912.                               &StorageTmp->mteTriggerThresholdDeltaFalling,
  913.                               &tmpint);
  915.     line =
  916.         read_config_read_data(ASN_OCTET_STR, line,
  917.                               &StorageTmp->mteTriggerThresholdObjectsOwner,
  918.                               &StorageTmp->
  919.                               mteTriggerThresholdObjectsOwnerLen);
  920.     if (StorageTmp->mteTriggerThresholdObjectsOwner == NULL) {
  921.         config_perror
  922.             ("invalid specification for mteTriggerThresholdObjectsOwner");
  923.         return;
  924.     }
  926.     line =
  927.         read_config_read_data(ASN_OCTET_STR, line,
  928.                               &StorageTmp->mteTriggerThresholdObjects,
  929.                               &StorageTmp->mteTriggerThresholdObjectsLen);
  930.     if (StorageTmp->mteTriggerThresholdObjects == NULL) {
  931.         config_perror
  932.             ("invalid specification for mteTriggerThresholdObjects");
  933.         return;
  934.     }
  936.     line =
  937.         read_config_read_data(ASN_OCTET_STR, line,
  938.                               &StorageTmp->
  939.                               mteTriggerThresholdRisingEventOwner,
  940.                               &StorageTmp->
  941.                               mteTriggerThresholdRisingEventOwnerLen);
  942.     if (StorageTmp->mteTriggerThresholdRisingEventOwner == NULL) {
  943.         config_perror
  944.             ("invalid specification for mteTriggerThresholdRisingEventOwner");
  945.         return;
  946.     }
  948.     line =
  949.         read_config_read_data(ASN_OCTET_STR, line,
  950.                               &StorageTmp->mteTriggerThresholdRisingEvent,
  951.                               &StorageTmp->
  952.                               mteTriggerThresholdRisingEventLen);
  953.     if (StorageTmp->mteTriggerThresholdRisingEvent == NULL) {
  954.         config_perror
  955.             ("invalid specification for mteTriggerThresholdRisingEvent");
  956.         return;
  957.     }
  959.     line =
  960.         read_config_read_data(ASN_OCTET_STR, line,
  961.                               &StorageTmp->
  962.                               mteTriggerThresholdFallingEventOwner,
  963.                               &StorageTmp->
  964.                               mteTriggerThresholdFallingEventOwnerLen);
  965.     if (StorageTmp->mteTriggerThresholdFallingEventOwner == NULL) {
  966.         config_perror
  967.             ("invalid specification for mteTriggerThresholdFallingEventOwner");
  968.         return;
  969.     }
  971.     line =
  972.         read_config_read_data(ASN_OCTET_STR, line,
  973.                               &StorageTmp->mteTriggerThresholdFallingEvent,
  974.                               &StorageTmp->
  975.                               mteTriggerThresholdFallingEventLen);
  976.     if (StorageTmp->mteTriggerThresholdFallingEvent == NULL) {
  977.         config_perror
  978.             ("invalid specification for mteTriggerThresholdFallingEvent");
  979.         return;
  980.     }
  982.     line =
  983.         read_config_read_data(ASN_OCTET_STR, line,
  984.                               &StorageTmp->
  985.                               mteTriggerThresholdDeltaRisingEventOwner,
  986.                               &StorageTmp->
  987.                               mteTriggerThresholdDeltaRisingEventOwnerLen);
  988.     if (StorageTmp->mteTriggerThresholdDeltaRisingEventOwner == NULL) {
  989.         config_perror
  990.             ("invalid specification for mteTriggerThresholdDeltaRisingEventOwner");
  991.         return;
  992.     }
  994.     line =
  995.         read_config_read_data(ASN_OCTET_STR, line,
  996.                               &StorageTmp->
  997.                               mteTriggerThresholdDeltaRisingEvent,
  998.                               &StorageTmp->
  999.                               mteTriggerThresholdDeltaRisingEventLen);
  1000.     if (StorageTmp->mteTriggerThresholdDeltaRisingEvent == NULL) {
  1001.         config_perror
  1002.             ("invalid specification for mteTriggerThresholdDeltaRisingEvent");
  1003.         return;
  1004.     }
  1006.     line =
  1007.         read_config_read_data(ASN_OCTET_STR, line,
  1008.                               &StorageTmp->
  1009.                               mteTriggerThresholdDeltaFallingEventOwner,
  1010.                               &StorageTmp->
  1011.                               mteTriggerThresholdDeltaFallingEventOwnerLen);
  1012.     if (StorageTmp->mteTriggerThresholdDeltaFallingEventOwner == NULL) {
  1013.         config_perror
  1014.             ("invalid specification for mteTriggerThresholdDeltaFallingEventOwner");
  1015.         return;
  1016.     }
  1018.     line =
  1019.         read_config_read_data(ASN_OCTET_STR, line,
  1020.                               &StorageTmp->
  1021.                               mteTriggerThresholdDeltaFallingEvent,
  1022.                               &StorageTmp->
  1023.                               mteTriggerThresholdDeltaFallingEventLen);
  1024.     if (StorageTmp->mteTriggerThresholdDeltaFallingEvent == NULL) {
  1025.         config_perror
  1026.             ("invalid specification for mteTriggerThresholdDeltaFallingEvent");
  1027.         return;
  1028.     }
  1030.     /*
  1031.      * local internal variables 
  1032.      */
  1033.     line =
  1034.         read_config_read_data(ASN_INTEGER, line,
  1035.                               &StorageTmp->have_copied_auth_info, &tmpint);
  1036.     if (StorageTmp->have_copied_auth_info) {
  1037.         line =
  1038.             read_config_read_data(ASN_INTEGER, line,
  1039.                                   &StorageTmp->pdu_version, &tmpint);
  1040.         line =
  1041.             read_config_read_data(ASN_INTEGER, line,
  1042.                                   &StorageTmp->pdu_securityModel, &tmpint);
  1043.         line =
  1044.             read_config_read_data(ASN_INTEGER, line,
  1045.                                   &StorageTmp->pdu_securityLevel, &tmpint);
  1046.         line =
  1047.             read_config_read_data(ASN_OBJECT_ID, line, &tmpoid, &tmpint);
  1048.         if (!netsnmp_tdomain_support
  1049.             (tmpoid, tmpint, &StorageTmp->pdu_tDomain,
  1050.              &StorageTmp->pdu_tDomainLen)) {
  1051.             config_perror
  1052.                 ("unsupported transport domain for mteTriggerEntry");
  1053.             return;
  1054.         }
  1055.         if (tmpoid != NULL) {
  1056.             free(tmpoid);
  1057.         }
  1059.         /*
  1060.          * can be NULL?  Yes.  
  1061.          */
  1062.         line = read_config_read_data(ASN_OCTET_STR, line,
  1063.                                      &(StorageTmp->pdu_transport),
  1064.                                      &StorageTmp->pdu_transportLen);
  1066.         line =
  1067.             read_config_read_data(ASN_OCTET_STR, line,
  1068.                                   &StorageTmp->pdu_community,
  1069.                                   &StorageTmp->pdu_community_len);
  1070.         if (StorageTmp->pdu_community == NULL) {
  1071.             config_perror("invalid specification for pdu_community");
  1072.             return;
  1073.         }
  1074.         line =
  1075.             read_config_read_data(ASN_OCTET_STR, line,
  1076.                                   &StorageTmp->pdu_securityName,
  1077.                                   &StorageTmp->pdu_securityNameLen);
  1078.         if (StorageTmp->pdu_securityName == NULL) {
  1079.             config_perror("invalid specification for pdu_securityName");
  1080.             return;
  1081.         }
  1082.     }
  1083.     StorageTmp->storageType = ST_NONVOLATILE;   /* the only type stored */
  1085.     mteTriggerTable_add(StorageTmp);
  1087.     /*
  1088.      * technically this is too early 
  1089.      */
  1090.     if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
  1091.         StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
  1092.         mte_enable_trigger(StorageTmp);
  1094.     DEBUGMSGTL(("mteTriggerTable", "done.n"));
  1095. }
  1100. /*
  1101.  * store_mteTriggerTable():
  1102.  *   stores .conf file entries needed to configure the mib.
  1103.  */
  1104. int
  1105. store_mteTriggerTable(int majorID, int minorID, void *serverarg,
  1106.                       void *clientarg)
  1107. {
  1108.     char            line[SNMP_MAXBUF];
  1109.     char           *cptr;
  1110.     size_t          tmpint;
  1111.     struct mteTriggerTable_data *StorageTmp;
  1112.     struct header_complex_index *hcindex;
  1114.     DEBUGMSGTL(("mteTriggerTable", "storing data...  "));
  1116.     for (hcindex = mteTriggerTableStorage; hcindex != NULL;
  1117.          hcindex = hcindex->next) {
  1118.         StorageTmp = (struct mteTriggerTable_data *) hcindex->data;
  1121.         if (StorageTmp->storageType == ST_NONVOLATILE) {
  1123.             memset(line, 0, sizeof(line));
  1124.             strcat(line, "mteTriggerTable ");
  1125.             cptr = line + strlen(line);
  1127.             cptr =
  1128.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1129.                                        &StorageTmp->mteOwner,
  1130.                                        &StorageTmp->mteOwnerLen);
  1131.             cptr =
  1132.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1133.                                        &StorageTmp->mteTriggerName,
  1134.                                        &StorageTmp->mteTriggerNameLen);
  1135.             cptr =
  1136.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1137.                                        &StorageTmp->mteTriggerComment,
  1138.                                        &StorageTmp->mteTriggerCommentLen);
  1139.             cptr =
  1140.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1141.                                        &StorageTmp->mteTriggerTest,
  1142.                                        &StorageTmp->mteTriggerTestLen);
  1143.             cptr =
  1144.                 read_config_store_data(ASN_INTEGER, cptr,
  1145.                                        &StorageTmp->mteTriggerSampleType,
  1146.                                        &tmpint);
  1147.             cptr =
  1148.                 read_config_store_data(ASN_OBJECT_ID, cptr,
  1149.                                        &StorageTmp->mteTriggerValueID,
  1150.                                        &StorageTmp->mteTriggerValueIDLen);
  1151.             cptr =
  1152.                 read_config_store_data(ASN_INTEGER, cptr,
  1153.                                        &StorageTmp->
  1154.                                        mteTriggerValueIDWildcard, &tmpint);
  1155.             cptr =
  1156.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1157.                                        &StorageTmp->mteTriggerTargetTag,
  1158.                                        &StorageTmp->
  1159.                                        mteTriggerTargetTagLen);
  1160.             cptr =
  1161.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1162.                                        &StorageTmp->mteTriggerContextName,
  1163.                                        &StorageTmp->
  1164.                                        mteTriggerContextNameLen);
  1165.             cptr =
  1166.                 read_config_store_data(ASN_INTEGER, cptr,
  1167.                                        &StorageTmp->
  1168.                                        mteTriggerContextNameWildcard,
  1169.                                        &tmpint);
  1170.             cptr =
  1171.                 read_config_store_data(ASN_UNSIGNED, cptr,
  1172.                                        &StorageTmp->mteTriggerFrequency,
  1173.                                        &tmpint);
  1174.             cptr =
  1175.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1176.                                        &StorageTmp->mteTriggerObjectsOwner,
  1177.                                        &StorageTmp->
  1178.                                        mteTriggerObjectsOwnerLen);
  1179.             cptr =
  1180.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1181.                                        &StorageTmp->mteTriggerObjects,
  1182.                                        &StorageTmp->mteTriggerObjectsLen);
  1183.             cptr =
  1184.                 read_config_store_data(ASN_INTEGER, cptr,
  1185.                                        &StorageTmp->mteTriggerEnabled,
  1186.                                        &tmpint);
  1187.             cptr =
  1188.                 read_config_store_data(ASN_INTEGER, cptr,
  1189.                                        &StorageTmp->mteTriggerEntryStatus,
  1190.                                        &tmpint);
  1192.             /*
  1193.              * delta table 
  1194.              */
  1195.             cptr =
  1196.                 read_config_store_data(ASN_OBJECT_ID, cptr,
  1197.                                        &StorageTmp->
  1198.                                        mteTriggerDeltaDiscontinuityID,
  1199.                                        &StorageTmp->
  1200.                                        mteTriggerDeltaDiscontinuityIDLen);
  1201.             cptr =
  1202.                 read_config_store_data(ASN_INTEGER, cptr,
  1203.                                        &StorageTmp->
  1204.                                        mteTriggerDeltaDiscontinuityIDWildcard,
  1205.                                        &tmpint);
  1206.             cptr =
  1207.                 read_config_store_data(ASN_INTEGER, cptr,
  1208.                                        &StorageTmp->
  1209.                                        mteTriggerDeltaDiscontinuityIDType,
  1210.                                        &tmpint);
  1212.             /*
  1213.              * existence table 
  1214.              */
  1215.             cptr =
  1216.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1217.                                        &StorageTmp->
  1218.                                        mteTriggerExistenceTest,
  1219.                                        &StorageTmp->
  1220.                                        mteTriggerExistenceTestLen);
  1221.             cptr =
  1222.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1223.                                        &StorageTmp->
  1224.                                        mteTriggerExistenceStartup,
  1225.                                        &StorageTmp->
  1226.                                        mteTriggerExistenceStartupLen);
  1227.             cptr =
  1228.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1229.                                        &StorageTmp->
  1230.                                        mteTriggerExistenceObjectsOwner,
  1231.                                        &StorageTmp->
  1232.                                        mteTriggerExistenceObjectsOwnerLen);
  1233.             cptr =
  1234.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1235.                                        &StorageTmp->
  1236.                                        mteTriggerExistenceObjects,
  1237.                                        &StorageTmp->
  1238.                                        mteTriggerExistenceObjectsLen);
  1239.             cptr =
  1240.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1241.                                        &StorageTmp->
  1242.                                        mteTriggerExistenceEventOwner,
  1243.                                        &StorageTmp->
  1244.                                        mteTriggerExistenceEventOwnerLen);
  1245.             cptr =
  1246.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1247.                                        &StorageTmp->
  1248.                                        mteTriggerExistenceEvent,
  1249.                                        &StorageTmp->
  1250.                                        mteTriggerExistenceEventLen);
  1252.             /*
  1253.              * boolean table 
  1254.              */
  1255.             cptr =
  1256.                 read_config_store_data(ASN_INTEGER, cptr,
  1257.                                        &StorageTmp->
  1258.                                        mteTriggerBooleanComparison,
  1259.                                        &tmpint);
  1260.             cptr =
  1261.                 read_config_store_data(ASN_INTEGER, cptr,
  1262.                                        &StorageTmp->mteTriggerBooleanValue,
  1263.                                        &tmpint);
  1264.             cptr =
  1265.                 read_config_store_data(ASN_INTEGER, cptr,
  1266.                                        &StorageTmp->
  1267.                                        mteTriggerBooleanStartup, &tmpint);
  1268.             cptr =
  1269.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1270.                                        &StorageTmp->
  1271.                                        mteTriggerBooleanObjectsOwner,
  1272.                                        &StorageTmp->
  1273.                                        mteTriggerBooleanObjectsOwnerLen);
  1274.             cptr =
  1275.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1276.                                        &StorageTmp->
  1277.                                        mteTriggerBooleanObjects,
  1278.                                        &StorageTmp->
  1279.                                        mteTriggerBooleanObjectsLen);
  1280.             cptr =
  1281.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1282.                                        &StorageTmp->
  1283.                                        mteTriggerBooleanEventOwner,
  1284.                                        &StorageTmp->
  1285.                                        mteTriggerBooleanEventOwnerLen);
  1286.             cptr =
  1287.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1288.                                        &StorageTmp->mteTriggerBooleanEvent,
  1289.                                        &StorageTmp->
  1290.                                        mteTriggerBooleanEventLen);
  1292.             /*
  1293.              * threshold table 
  1294.              */
  1295.             cptr =
  1296.                 read_config_store_data(ASN_INTEGER, cptr,
  1297.                                        &StorageTmp->
  1298.                                        mteTriggerThresholdStartup,
  1299.                                        &tmpint);
  1300.             cptr =
  1301.                 read_config_store_data(ASN_INTEGER, cptr,
  1302.                                        &StorageTmp->
  1303.                                        mteTriggerThresholdRising, &tmpint);
  1304.             cptr =
  1305.                 read_config_store_data(ASN_INTEGER, cptr,
  1306.                                        &StorageTmp->
  1307.                                        mteTriggerThresholdFalling,
  1308.                                        &tmpint);
  1309.             cptr =
  1310.                 read_config_store_data(ASN_INTEGER, cptr,
  1311.                                        &StorageTmp->
  1312.                                        mteTriggerThresholdDeltaRising,
  1313.                                        &tmpint);
  1314.             cptr =
  1315.                 read_config_store_data(ASN_INTEGER, cptr,
  1316.                                        &StorageTmp->
  1317.                                        mteTriggerThresholdDeltaFalling,
  1318.                                        &tmpint);
  1319.             cptr =
  1320.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1321.                                        &StorageTmp->
  1322.                                        mteTriggerThresholdObjectsOwner,
  1323.                                        &StorageTmp->
  1324.                                        mteTriggerThresholdObjectsOwnerLen);
  1325.             cptr =
  1326.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1327.                                        &StorageTmp->
  1328.                                        mteTriggerThresholdObjects,
  1329.                                        &StorageTmp->
  1330.                                        mteTriggerThresholdObjectsLen);
  1331.             cptr =
  1332.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1333.                                        &StorageTmp->
  1334.                                        mteTriggerThresholdRisingEventOwner,
  1335.                                        &StorageTmp->
  1336.                                        mteTriggerThresholdRisingEventOwnerLen);
  1337.             cptr =
  1338.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1339.                                        &StorageTmp->
  1340.                                        mteTriggerThresholdRisingEvent,
  1341.                                        &StorageTmp->
  1342.                                        mteTriggerThresholdRisingEventLen);
  1343.             cptr =
  1344.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1345.                                        &StorageTmp->
  1346.                                        mteTriggerThresholdFallingEventOwner,
  1347.                                        &StorageTmp->
  1348.                                        mteTriggerThresholdFallingEventOwnerLen);
  1349.             cptr =
  1350.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1351.                                        &StorageTmp->
  1352.                                        mteTriggerThresholdFallingEvent,
  1353.                                        &StorageTmp->
  1354.                                        mteTriggerThresholdFallingEventLen);
  1355.             cptr =
  1356.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1357.                                        &StorageTmp->
  1358.                                        mteTriggerThresholdDeltaRisingEventOwner,
  1359.                                        &StorageTmp->
  1360.                                        mteTriggerThresholdDeltaRisingEventOwnerLen);
  1361.             cptr =
  1362.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1363.                                        &StorageTmp->
  1364.                                        mteTriggerThresholdDeltaRisingEvent,
  1365.                                        &StorageTmp->
  1366.                                        mteTriggerThresholdDeltaRisingEventLen);
  1367.             cptr =
  1368.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1369.                                        &StorageTmp->
  1370.                                        mteTriggerThresholdDeltaFallingEventOwner,
  1371.                                        &StorageTmp->
  1372.                                        mteTriggerThresholdDeltaFallingEventOwnerLen);
  1373.             cptr =
  1374.                 read_config_store_data(ASN_OCTET_STR, cptr,
  1375.                                        &StorageTmp->
  1376.                                        mteTriggerThresholdDeltaFallingEvent,
  1377.                                        &StorageTmp->
  1378.                                        mteTriggerThresholdDeltaFallingEventLen);
  1380.             /*
  1381.              * local internal variables 
  1382.              */
  1383.             cptr =
  1384.                 read_config_store_data(ASN_INTEGER, cptr,
  1385.                                        &StorageTmp->have_copied_auth_info,
  1386.                                        &tmpint);
  1387.             if (StorageTmp->have_copied_auth_info) {
  1388.                 cptr =
  1389.                     read_config_store_data(ASN_INTEGER, cptr,
  1390.                                            &StorageTmp->pdu_version,
  1391.                                            &tmpint);
  1392.                 cptr =
  1393.                     read_config_store_data(ASN_INTEGER, cptr,
  1394.                                            &StorageTmp->pdu_securityModel,
  1395.                                            &tmpint);
  1396.                 cptr =
  1397.                     read_config_store_data(ASN_INTEGER, cptr,
  1398.                                            &StorageTmp->pdu_securityLevel,
  1399.                                            &tmpint);
  1400.                 cptr =
  1401.                     read_config_store_data(ASN_OBJECT_ID, cptr,
  1402.                                            (void *)(&StorageTmp->pdu_tDomain),
  1403.                                            &StorageTmp->pdu_tDomainLen);
  1404.                 cptr =
  1405.                     read_config_store_data(ASN_OCTET_STR, cptr,
  1406.                                            &StorageTmp->pdu_transport,
  1407.                                            &StorageTmp->pdu_transportLen);
  1408.                 cptr =
  1409.                     read_config_store_data(ASN_OCTET_STR, cptr,
  1410.                                            &StorageTmp->pdu_community,
  1411.                                            &StorageTmp->pdu_community_len);
  1412.                 cptr =
  1413.                     read_config_store_data(ASN_OCTET_STR, cptr,
  1414.                                            &StorageTmp->pdu_securityName,
  1415.                                            &StorageTmp->
  1416.                                            pdu_securityNameLen);
  1417.             }
  1419.             snmpd_store_config(line);
  1420.         }
  1421.     }
  1422.     DEBUGMSGTL(("mteTriggerTable", "done.n"));
  1423.     return SNMPERR_SUCCESS;
  1424. }
  1429. /*
  1430.  * var_mteTriggerTable():
  1431.  *   Handle this table separately from the scalar value case.
  1432.  *   The workings of this are basically the same as for var_mteTriggerTable above.
  1433.  */
  1434. unsigned char  *
  1435. var_mteTriggerTable(struct variable *vp,
  1436.                     oid * name,
  1437.                     size_t * length,
  1438.                     int exact,
  1439.                     size_t * var_len, WriteMethod ** write_method)
  1440. {
  1443.     struct mteTriggerTable_data *StorageTmp = NULL;
  1446.     DEBUGMSGTL(("mteTriggerTable",
  1447.                 "var_mteTriggerTable: Entering...  n"));
  1448.     /*
  1449.      * this assumes you have registered all your data properly
  1450.      */
  1451.     if ((StorageTmp =
  1452.          header_complex(mteTriggerTableStorage, vp, name, length, exact,
  1453.                         var_len, write_method)) == NULL) {
  1454.         if (vp->magic == MTETRIGGERENTRYSTATUS)
  1455.             *write_method = write_mteTriggerEntryStatus;
  1456.         return NULL;
  1457.     }
  1460.     /*
  1461.      * this is where we do the value assignments for the mib results.
  1462.      */
  1463.     switch (vp->magic) {
  1466.     case MTETRIGGERCOMMENT:
  1467.         *write_method = write_mteTriggerComment;
  1468.         *var_len = StorageTmp->mteTriggerCommentLen;
  1469.         return (u_char *) StorageTmp->mteTriggerComment;
  1471.     case MTETRIGGERTEST:
  1472.         *write_method = write_mteTriggerTest;
  1473.         *var_len = StorageTmp->mteTriggerTestLen;
  1474.         return (u_char *) StorageTmp->mteTriggerTest;
  1476.     case MTETRIGGERSAMPLETYPE:
  1477.         *write_method = write_mteTriggerSampleType;
  1478.         *var_len = sizeof(StorageTmp->mteTriggerSampleType);
  1479.         return (u_char *) & StorageTmp->mteTriggerSampleType;
  1481.     case MTETRIGGERVALUEID:
  1482.         *write_method = write_mteTriggerValueID;
  1483.         *var_len = StorageTmp->mteTriggerValueIDLen * sizeof(oid);
  1484.         return (u_char *) StorageTmp->mteTriggerValueID;
  1486.     case MTETRIGGERVALUEIDWILDCARD:
  1487.         *write_method = write_mteTriggerValueIDWildcard;
  1488.         *var_len = sizeof(StorageTmp->mteTriggerValueIDWildcard);
  1489.         return (u_char *) & StorageTmp->mteTriggerValueIDWildcard;
  1491.     case MTETRIGGERTARGETTAG:
  1492.         *write_method = write_mteTriggerTargetTag;
  1493.         *var_len = StorageTmp->mteTriggerTargetTagLen;
  1494.         return (u_char *) StorageTmp->mteTriggerTargetTag;
  1496.     case MTETRIGGERCONTEXTNAME:
  1497.         *write_method = write_mteTriggerContextName;
  1498.         *var_len = StorageTmp->mteTriggerContextNameLen;
  1499.         return (u_char *) StorageTmp->mteTriggerContextName;
  1501.     case MTETRIGGERCONTEXTNAMEWILDCARD:
  1502.         *write_method = write_mteTriggerContextNameWildcard;
  1503.         *var_len = sizeof(StorageTmp->mteTriggerContextNameWildcard);
  1504.         return (u_char *) & StorageTmp->mteTriggerContextNameWildcard;
  1506.     case MTETRIGGERFREQUENCY:
  1507.         *write_method = write_mteTriggerFrequency;
  1508.         *var_len = sizeof(StorageTmp->mteTriggerFrequency);
  1509.         return (u_char *) & StorageTmp->mteTriggerFrequency;
  1511.     case MTETRIGGEROBJECTSOWNER:
  1512.         *write_method = write_mteTriggerObjectsOwner;
  1513.         *var_len = StorageTmp->mteTriggerObjectsOwnerLen;
  1514.         return (u_char *) StorageTmp->mteTriggerObjectsOwner;
  1516.     case MTETRIGGEROBJECTS:
  1517.         *write_method = write_mteTriggerObjects;
  1518.         *var_len = StorageTmp->mteTriggerObjectsLen;
  1519.         return (u_char *) StorageTmp->mteTriggerObjects;
  1521.     case MTETRIGGERENABLED:
  1522.         *write_method = write_mteTriggerEnabled;
  1523.         *var_len = sizeof(StorageTmp->mteTriggerEnabled);
  1524.         return (u_char *) & StorageTmp->mteTriggerEnabled;
  1526.     case MTETRIGGERENTRYSTATUS:
  1527.         *write_method = write_mteTriggerEntryStatus;
  1528.         *var_len = sizeof(StorageTmp->mteTriggerEntryStatus);
  1529.         return (u_char *) & StorageTmp->mteTriggerEntryStatus;
  1532.     default:
  1533.         ERROR_MSG("");
  1534.     }
  1535.     return NULL;
  1536. }
  1541. int
  1542. write_mteTriggerComment(int action,
  1543.                         u_char * var_val,
  1544.                         u_char var_val_type,
  1545.                         size_t var_val_len,
  1546.                         u_char * statP, oid * name, size_t name_len)
  1547. {
  1548.     static char    *tmpvar;
  1549.     struct mteTriggerTable_data *StorageTmp = NULL;
  1550.     static size_t   tmplen;
  1551.     size_t          newlen =
  1552.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  1553.                     3 - 1);
  1556.     DEBUGMSGTL(("mteTriggerTable",
  1557.                 "write_mteTriggerComment entering action=%d...  n",
  1558.                 action));
  1559.     if ((StorageTmp =
  1560.          header_complex(mteTriggerTableStorage, NULL,
  1561.                         &name[sizeof(mteTriggerTable_variables_oid) /
  1562.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1563.                         NULL)) == NULL)
  1564.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1567.     switch (action) {
  1568.     case RESERVE1:
  1569.         if (var_val_type != ASN_OCTET_STR) {
  1570.             snmp_log(LOG_ERR,
  1571.                      "write to mteTriggerComment not ASN_OCTET_STRn");
  1572.             return SNMP_ERR_WRONGTYPE;
  1573.         }
  1574.         if (StorageTmp->storageType != ST_NONVOLATILE)
  1575.             return SNMP_ERR_NOTWRITABLE;
  1577.         break;
  1580.     case RESERVE2:
  1581.         /*
  1582.          * memory reseveration, final preparation... 
  1583.          */
  1584.         break;
  1587.     case FREE:
  1588.         /*
  1589.          * Release any resources that have been allocated 
  1590.          */
  1591.         break;
  1594.     case ACTION:
  1595.         /*
  1596.          * The variable has been stored in string for
  1597.          * you to use, and you have just been asked to do something with
  1598.          * it.  Note that anything done here must be reversable in the UNDO case 
  1599.          */
  1600.         tmpvar = StorageTmp->mteTriggerComment;
  1601.         tmplen = StorageTmp->mteTriggerCommentLen;
  1602.         memdup((u_char **) & StorageTmp->mteTriggerComment, var_val,
  1603.                var_val_len);
  1604.         StorageTmp->mteTriggerCommentLen = var_val_len;
  1605.         break;
  1608.     case UNDO:
  1609.         /*
  1610.          * Back out any changes made in the ACTION case 
  1611.          */
  1612.         SNMP_FREE(StorageTmp->mteTriggerComment);
  1613.         StorageTmp->mteTriggerComment = tmpvar;
  1614.         StorageTmp->mteTriggerCommentLen = tmplen;
  1615.         break;
  1618.     case COMMIT:
  1619.         /*
  1620.          * Things are working well, so it's now safe to make the change
  1621.          * permanently.  Make sure that anything done here can't fail! 
  1622.          */
  1623.         SNMP_FREE(tmpvar);
  1624.         break;
  1625.     }
  1626.     return SNMP_ERR_NOERROR;
  1627. }
  1631. int
  1632. write_mteTriggerTest(int action,
  1633.                      u_char * var_val,
  1634.                      u_char var_val_type,
  1635.                      size_t var_val_len,
  1636.                      u_char * statP, oid * name, size_t name_len)
  1637. {
  1638.     static char    *tmpvar;
  1639.     struct mteTriggerTable_data *StorageTmp = NULL;
  1640.     static size_t   tmplen;
  1641.     size_t          newlen =
  1642.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  1643.                     3 - 1);
  1646.     DEBUGMSGTL(("mteTriggerTable",
  1647.                 "write_mteTriggerTest entering action=%d...  n", action));
  1648.     if ((StorageTmp =
  1649.          header_complex(mteTriggerTableStorage, NULL,
  1650.                         &name[sizeof(mteTriggerTable_variables_oid) /
  1651.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1652.                         NULL)) == NULL)
  1653.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1656.     switch (action) {
  1657.     case RESERVE1:
  1658.         if (var_val_type != ASN_OCTET_STR) {
  1659.             snmp_log(LOG_ERR, "write to mteTriggerTest not ASN_OCTET_STRn");
  1660.             return SNMP_ERR_WRONGTYPE;
  1661.         }
  1662.         if (StorageTmp->storageType != ST_NONVOLATILE)
  1663.             return SNMP_ERR_NOTWRITABLE;
  1664.         break;
  1667.     case RESERVE2:
  1668.         /*
  1669.          * memory reseveration, final preparation... 
  1670.          */
  1671.         break;
  1674.     case FREE:
  1675.         /*
  1676.          * Release any resources that have been allocated 
  1677.          */
  1678.         break;
  1681.     case ACTION:
  1682.         /*
  1683.          * The variable has been stored in string for
  1684.          * you to use, and you have just been asked to do something with
  1685.          * it.  Note that anything done here must be reversable in the UNDO case 
  1686.          */
  1687.         tmpvar = StorageTmp->mteTriggerTest;
  1688.         tmplen = StorageTmp->mteTriggerTestLen;
  1689.         memdup((u_char **) & StorageTmp->mteTriggerTest, var_val,
  1690.                var_val_len);
  1691.         StorageTmp->mteTriggerTestLen = var_val_len;
  1692.         break;
  1695.     case UNDO:
  1696.         /*
  1697.          * Back out any changes made in the ACTION case 
  1698.          */
  1699.         SNMP_FREE(StorageTmp->mteTriggerTest);
  1700.         StorageTmp->mteTriggerTest = tmpvar;
  1701.         StorageTmp->mteTriggerTestLen = tmplen;
  1702.         break;
  1705.     case COMMIT:
  1706.         /*
  1707.          * Things are working well, so it's now safe to make the change
  1708.          * permanently.  Make sure that anything done here can't fail! 
  1709.          */
  1710.         SNMP_FREE(tmpvar);
  1711.         break;
  1712.     }
  1713.     return SNMP_ERR_NOERROR;
  1714. }
  1718. int
  1719. write_mteTriggerSampleType(int action,
  1720.                            u_char * var_val,
  1721.                            u_char var_val_type,
  1722.                            size_t var_val_len,
  1723.                            u_char * statP, oid * name, size_t name_len)
  1724. {
  1725.     static int      tmpvar;
  1726.     struct mteTriggerTable_data *StorageTmp = NULL;
  1727.     size_t          newlen =
  1728.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  1729.                     3 - 1);
  1732.     DEBUGMSGTL(("mteTriggerTable",
  1733.                 "write_mteTriggerSampleType entering action=%d...  n",
  1734.                 action));
  1735.     if ((StorageTmp =
  1736.          header_complex(mteTriggerTableStorage, NULL,
  1737.                         &name[sizeof(mteTriggerTable_variables_oid) /
  1738.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1739.                         NULL)) == NULL)
  1740.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1743.     switch (action) {
  1744.     case RESERVE1:
  1745.         if (var_val_type != ASN_INTEGER) {
  1746.             snmp_log(LOG_ERR,
  1747.                      "write to mteTriggerSampleType not ASN_INTEGERn");
  1748.             return SNMP_ERR_WRONGTYPE;
  1749.         }
  1750.         if (StorageTmp->storageType != ST_NONVOLATILE)
  1751.             return SNMP_ERR_NOTWRITABLE;
  1752.         break;
  1755.     case RESERVE2:
  1756.         /*
  1757.          * memory reseveration, final preparation... 
  1758.          */
  1759.         break;
  1762.     case FREE:
  1763.         /*
  1764.          * Release any resources that have been allocated 
  1765.          */
  1766.         break;
  1769.     case ACTION:
  1770.         /*
  1771.          * The variable has been stored in long_ret for
  1772.          * you to use, and you have just been asked to do something with
  1773.          * it.  Note that anything done here must be reversable in the UNDO case 
  1774.          */
  1775.         tmpvar = StorageTmp->mteTriggerSampleType;
  1776.         StorageTmp->mteTriggerSampleType = *((long *) var_val);
  1777.         break;
  1780.     case UNDO:
  1781.         /*
  1782.          * Back out any changes made in the ACTION case 
  1783.          */
  1784.         StorageTmp->mteTriggerSampleType = tmpvar;
  1785.         break;
  1788.     case COMMIT:
  1789.         /*
  1790.          * Things are working well, so it's now safe to make the change
  1791.          * permanently.  Make sure that anything done here can't fail! 
  1792.          */
  1794.         break;
  1795.     }
  1796.     return SNMP_ERR_NOERROR;
  1797. }
  1801. int
  1802. write_mteTriggerValueID(int action,
  1803.                         u_char * var_val,
  1804.                         u_char var_val_type,
  1805.                         size_t var_val_len,
  1806.                         u_char * statP, oid * name, size_t name_len)
  1807. {
  1808.     static oid     *tmpvar;
  1809.     struct mteTriggerTable_data *StorageTmp = NULL;
  1810.     static size_t   tmplen;
  1811.     size_t          newlen =
  1812.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  1813.                     3 - 1);
  1816.     DEBUGMSGTL(("mteTriggerTable",
  1817.                 "write_mteTriggerValueID entering action=%d...  n",
  1818.                 action));
  1819.     if ((StorageTmp =
  1820.          header_complex(mteTriggerTableStorage, NULL,
  1821.                         &name[sizeof(mteTriggerTable_variables_oid) /
  1822.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1823.                         NULL)) == NULL)
  1824.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1827.     switch (action) {
  1828.     case RESERVE1:
  1829.         if (var_val_type != ASN_OBJECT_ID) {
  1830.             snmp_log(LOG_ERR,
  1831.                      "write to mteTriggerValueID not ASN_OBJECT_IDn");
  1832.             return SNMP_ERR_WRONGTYPE;
  1833.         }
  1834.         if (StorageTmp->storageType != ST_NONVOLATILE)
  1835.             return SNMP_ERR_NOTWRITABLE;
  1836.         break;
  1839.     case RESERVE2:
  1840.         /*
  1841.          * memory reseveration, final preparation... 
  1842.          */
  1843.         break;
  1846.     case FREE:
  1847.         /*
  1848.          * Release any resources that have been allocated 
  1849.          */
  1850.         break;
  1853.     case ACTION:
  1854.         /*
  1855.          * The variable has been stored in objid for
  1856.          * you to use, and you have just been asked to do something with
  1857.          * it.  Note that anything done here must be reversable in the UNDO case 
  1858.          */
  1859.         tmpvar = StorageTmp->mteTriggerValueID;
  1860.         tmplen = StorageTmp->mteTriggerValueIDLen;
  1861.         memdup((u_char **) & StorageTmp->mteTriggerValueID, var_val,
  1862.                var_val_len);
  1863.         StorageTmp->mteTriggerValueIDLen = var_val_len / sizeof(oid);
  1864.         break;
  1867.     case UNDO:
  1868.         /*
  1869.          * Back out any changes made in the ACTION case 
  1870.          */
  1871.         SNMP_FREE(StorageTmp->mteTriggerValueID);
  1872.         StorageTmp->mteTriggerValueID = tmpvar;
  1873.         StorageTmp->mteTriggerValueIDLen = tmplen;
  1874.         break;
  1877.     case COMMIT:
  1878.         /*
  1879.          * Things are working well, so it's now safe to make the change
  1880.          * permanently.  Make sure that anything done here can't fail! 
  1881.          */
  1883.         /*
  1884.          * XXX: if the valueID has actually changed, shouldn't we dump any
  1885.          * previous values, as these are from a different object?  
  1886.          */
  1887.         SNMP_FREE(tmpvar);
  1888.         break;
  1889.     }
  1890.     return SNMP_ERR_NOERROR;
  1891. }
  1895. int
  1896. write_mteTriggerValueIDWildcard(int action,
  1897.                                 u_char * var_val,
  1898.                                 u_char var_val_type,
  1899.                                 size_t var_val_len,
  1900.                                 u_char * statP,
  1901.                                 oid * name, size_t name_len)
  1902. {
  1903.     static int      tmpvar;
  1904.     struct mteTriggerTable_data *StorageTmp = NULL;
  1905.     size_t          newlen =
  1906.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  1907.                     3 - 1);
  1910.     DEBUGMSGTL(("mteTriggerTable",
  1911.                 "write_mteTriggerValueIDWildcard entering action=%d...  n",
  1912.                 action));
  1913.     if ((StorageTmp =
  1914.          header_complex(mteTriggerTableStorage, NULL,
  1915.                         &name[sizeof(mteTriggerTable_variables_oid) /
  1916.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1917.                         NULL)) == NULL)
  1918.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1921.     switch (action) {
  1922.     case RESERVE1:
  1923.         if (var_val_type != ASN_INTEGER) {
  1924.             snmp_log(LOG_ERR,
  1925.                      "write to mteTriggerValueIDWildcard not ASN_INTEGERn");
  1926.             return SNMP_ERR_WRONGTYPE;
  1927.         }
  1928.         if (StorageTmp->storageType != ST_NONVOLATILE)
  1929.             return SNMP_ERR_NOTWRITABLE;
  1930.         break;
  1933.     case RESERVE2:
  1934.         /*
  1935.          * memory reseveration, final preparation... 
  1936.          */
  1937.         break;
  1940.     case FREE:
  1941.         /*
  1942.          * Release any resources that have been allocated 
  1943.          */
  1944.         break;
  1947.     case ACTION:
  1948.         /*
  1949.          * The variable has been stored in long_ret for
  1950.          * you to use, and you have just been asked to do something with
  1951.          * it.  Note that anything done here must be reversable in the UNDO case 
  1952.          */
  1953.         tmpvar = StorageTmp->mteTriggerValueIDWildcard;
  1954.         StorageTmp->mteTriggerValueIDWildcard = *((long *) var_val);
  1955.         break;
  1958.     case UNDO:
  1959.         /*
  1960.          * Back out any changes made in the ACTION case 
  1961.          */
  1962.         StorageTmp->mteTriggerValueIDWildcard = tmpvar;
  1963.         break;
  1966.     case COMMIT:
  1967.         /*
  1968.          * Things are working well, so it's now safe to make the change
  1969.          * permanently.  Make sure that anything done here can't fail! 
  1970.          */
  1972.         break;
  1973.     }
  1974.     return SNMP_ERR_NOERROR;
  1975. }
  1979. int
  1980. write_mteTriggerTargetTag(int action,
  1981.                           u_char * var_val,
  1982.                           u_char var_val_type,
  1983.                           size_t var_val_len,
  1984.                           u_char * statP, oid * name, size_t name_len)
  1985. {
  1986.     static char    *tmpvar;
  1987.     struct mteTriggerTable_data *StorageTmp = NULL;
  1988.     static size_t   tmplen;
  1989.     size_t          newlen =
  1990.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  1991.                     3 - 1);
  1994.     DEBUGMSGTL(("mteTriggerTable",
  1995.                 "write_mteTriggerTargetTag entering action=%d...  n",
  1996.                 action));
  1997.     if ((StorageTmp =
  1998.          header_complex(mteTriggerTableStorage, NULL,
  1999.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2000.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2001.                         NULL)) == NULL)
  2002.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2005.     switch (action) {
  2006.     case RESERVE1:
  2007.         if (var_val_type != ASN_OCTET_STR) {
  2008.             snmp_log(LOG_ERR,
  2009.                      "write to mteTriggerTargetTag not ASN_OCTET_STRn");
  2010.             return SNMP_ERR_WRONGTYPE;
  2011.         }
  2012.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2013.             return SNMP_ERR_NOTWRITABLE;
  2014.         break;
  2017.     case RESERVE2:
  2018.         /*
  2019.          * memory reseveration, final preparation... 
  2020.          */
  2021.         break;
  2024.     case FREE:
  2025.         /*
  2026.          * Release any resources that have been allocated 
  2027.          */
  2028.         break;
  2031.     case ACTION:
  2032.         /*
  2033.          * The variable has been stored in string for
  2034.          * you to use, and you have just been asked to do something with
  2035.          * it.  Note that anything done here must be reversable in the UNDO case 
  2036.          */
  2037.         tmpvar = StorageTmp->mteTriggerTargetTag;
  2038.         tmplen = StorageTmp->mteTriggerTargetTagLen;
  2039.         memdup((u_char **) & StorageTmp->mteTriggerTargetTag, var_val,
  2040.                var_val_len);
  2041.         StorageTmp->mteTriggerTargetTagLen = var_val_len;
  2042.         break;
  2045.     case UNDO:
  2046.         /*
  2047.          * Back out any changes made in the ACTION case 
  2048.          */
  2049.         SNMP_FREE(StorageTmp->mteTriggerTargetTag);
  2050.         StorageTmp->mteTriggerTargetTag = tmpvar;
  2051.         StorageTmp->mteTriggerTargetTagLen = tmplen;
  2052.         break;
  2055.     case COMMIT:
  2056.         /*
  2057.          * Things are working well, so it's now safe to make the change
  2058.          * permanently.  Make sure that anything done here can't fail! 
  2059.          */
  2060.         SNMP_FREE(tmpvar);
  2061.         break;
  2062.     }
  2063.     return SNMP_ERR_NOERROR;
  2064. }
  2068. int
  2069. write_mteTriggerContextName(int action,
  2070.                             u_char * var_val,
  2071.                             u_char var_val_type,
  2072.                             size_t var_val_len,
  2073.                             u_char * statP, oid * name, size_t name_len)
  2074. {
  2075.     static char    *tmpvar;
  2076.     struct mteTriggerTable_data *StorageTmp = NULL;
  2077.     static size_t   tmplen;
  2078.     size_t          newlen =
  2079.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2080.                     3 - 1);
  2083.     DEBUGMSGTL(("mteTriggerTable",
  2084.                 "write_mteTriggerContextName entering action=%d...  n",
  2085.                 action));
  2086.     if ((StorageTmp =
  2087.          header_complex(mteTriggerTableStorage, NULL,
  2088.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2089.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2090.                         NULL)) == NULL)
  2091.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2094.     switch (action) {
  2095.     case RESERVE1:
  2096.         if (var_val_type != ASN_OCTET_STR) {
  2097.             snmp_log(LOG_ERR,
  2098.                      "write to mteTriggerContextName not ASN_OCTET_STRn");
  2099.             return SNMP_ERR_WRONGTYPE;
  2100.         }
  2101.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2102.             return SNMP_ERR_NOTWRITABLE;
  2103.         break;
  2106.     case RESERVE2:
  2107.         /*
  2108.          * memory reseveration, final preparation... 
  2109.          */
  2110.         break;
  2113.     case FREE:
  2114.         /*
  2115.          * Release any resources that have been allocated 
  2116.          */
  2117.         break;
  2120.     case ACTION:
  2121.         /*
  2122.          * The variable has been stored in string for
  2123.          * you to use, and you have just been asked to do something with
  2124.          * it.  Note that anything done here must be reversable in the UNDO case 
  2125.          */
  2126.         tmpvar = StorageTmp->mteTriggerContextName;
  2127.         tmplen = StorageTmp->mteTriggerContextNameLen;
  2128.         memdup((u_char **) & StorageTmp->mteTriggerContextName, var_val,
  2129.                var_val_len);
  2130.         StorageTmp->mteTriggerContextNameLen = var_val_len;
  2131.         break;
  2134.     case UNDO:
  2135.         /*
  2136.          * Back out any changes made in the ACTION case 
  2137.          */
  2138.         SNMP_FREE(StorageTmp->mteTriggerContextName);
  2139.         StorageTmp->mteTriggerContextName = tmpvar;
  2140.         StorageTmp->mteTriggerContextNameLen = tmplen;
  2141.         break;
  2144.     case COMMIT:
  2145.         /*
  2146.          * Things are working well, so it's now safe to make the change
  2147.          * permanently.  Make sure that anything done here can't fail! 
  2148.          */
  2149.         SNMP_FREE(tmpvar);
  2150.         break;
  2151.     }
  2152.     return SNMP_ERR_NOERROR;
  2153. }
  2157. int
  2158. write_mteTriggerContextNameWildcard(int action,
  2159.                                     u_char * var_val,
  2160.                                     u_char var_val_type,
  2161.                                     size_t var_val_len,
  2162.                                     u_char * statP,
  2163.                                     oid * name, size_t name_len)
  2164. {
  2165.     static int      tmpvar;
  2166.     struct mteTriggerTable_data *StorageTmp = NULL;
  2167.     size_t          newlen =
  2168.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2169.                     3 - 1);
  2172.     DEBUGMSGTL(("mteTriggerTable",
  2173.                 "write_mteTriggerContextNameWildcard entering action=%d...  n",
  2174.                 action));
  2175.     if ((StorageTmp =
  2176.          header_complex(mteTriggerTableStorage, NULL,
  2177.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2178.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2179.                         NULL)) == NULL)
  2180.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2183.     switch (action) {
  2184.     case RESERVE1:
  2185.         if (var_val_type != ASN_INTEGER) {
  2186.             snmp_log(LOG_ERR,
  2187.                      "write to mteTriggerContextNameWildcard not ASN_INTEGERn");
  2188.             return SNMP_ERR_WRONGTYPE;
  2189.         }
  2190.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2191.             return SNMP_ERR_NOTWRITABLE;
  2192.         break;
  2195.     case RESERVE2:
  2196.         /*
  2197.          * memory reseveration, final preparation... 
  2198.          */
  2199.         break;
  2202.     case FREE:
  2203.         /*
  2204.          * Release any resources that have been allocated 
  2205.          */
  2206.         break;
  2209.     case ACTION:
  2210.         /*
  2211.          * The variable has been stored in long_ret for
  2212.          * you to use, and you have just been asked to do something with
  2213.          * it.  Note that anything done here must be reversable in the UNDO case 
  2214.          */
  2215.         tmpvar = StorageTmp->mteTriggerContextNameWildcard;
  2216.         StorageTmp->mteTriggerContextNameWildcard = *((long *) var_val);
  2217.         break;
  2220.     case UNDO:
  2221.         /*
  2222.          * Back out any changes made in the ACTION case 
  2223.          */
  2224.         StorageTmp->mteTriggerContextNameWildcard = tmpvar;
  2225.         break;
  2228.     case COMMIT:
  2229.         /*
  2230.          * Things are working well, so it's now safe to make the change
  2231.          * permanently.  Make sure that anything done here can't fail! 
  2232.          */
  2234.         break;
  2235.     }
  2236.     return SNMP_ERR_NOERROR;
  2237. }
  2241. int
  2242. write_mteTriggerFrequency(int action,
  2243.                           u_char * var_val,
  2244.                           u_char var_val_type,
  2245.                           size_t var_val_len,
  2246.                           u_char * statP, oid * name, size_t name_len)
  2247. {
  2248.     static int      tmpvar;
  2249.     struct mteTriggerTable_data *StorageTmp = NULL;
  2250.     size_t          newlen =
  2251.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2252.                     3 - 1);
  2255.     DEBUGMSGTL(("mteTriggerTable",
  2256.                 "write_mteTriggerFrequency entering action=%d...  n",
  2257.                 action));
  2258.     if ((StorageTmp =
  2259.          header_complex(mteTriggerTableStorage, NULL,
  2260.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2261.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2262.                         NULL)) == NULL)
  2263.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2266.     switch (action) {
  2267.     case RESERVE1:
  2268.         if (var_val_type != ASN_UNSIGNED) {
  2269.             snmp_log(LOG_ERR,
  2270.                      "write to mteTriggerFrequency not ASN_UNSIGNEDn");
  2271.             return SNMP_ERR_WRONGTYPE;
  2272.         }
  2273.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2274.             return SNMP_ERR_NOTWRITABLE;
  2275.         break;
  2278.     case RESERVE2:
  2279.         /*
  2280.          * memory reseveration, final preparation... 
  2281.          */
  2282.         break;
  2285.     case FREE:
  2286.         /*
  2287.          * Release any resources that have been allocated 
  2288.          */
  2289.         break;
  2292.     case ACTION:
  2293.         /*
  2294.          * The variable has been stored in ulong_ret for
  2295.          * you to use, and you have just been asked to do something with
  2296.          * it.  Note that anything done here must be reversable in the UNDO case 
  2297.          */
  2298.         tmpvar = StorageTmp->mteTriggerFrequency;
  2299.         StorageTmp->mteTriggerFrequency = *((unsigned long *) var_val);
  2300.         break;
  2303.     case UNDO:
  2304.         /*
  2305.          * Back out any changes made in the ACTION case 
  2306.          */
  2307.         StorageTmp->mteTriggerFrequency = tmpvar;
  2308.         break;
  2311.     case COMMIT:
  2312.         /*
  2313.          * Things are working well, so it's now safe to make the change
  2314.          * permanently.  Make sure that anything done here can't fail! 
  2315.          */
  2316.         if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
  2317.             StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
  2318.             mte_enable_trigger(StorageTmp);
  2320.         break;
  2321.     }
  2322.     return SNMP_ERR_NOERROR;
  2323. }
  2327. int
  2328. write_mteTriggerObjectsOwner(int action,
  2329.                              u_char * var_val,
  2330.                              u_char var_val_type,
  2331.                              size_t var_val_len,
  2332.                              u_char * statP, oid * name, size_t name_len)
  2333. {
  2334.     static char    *tmpvar;
  2335.     struct mteTriggerTable_data *StorageTmp = NULL;
  2336.     static size_t   tmplen;
  2337.     size_t          newlen =
  2338.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2339.                     3 - 1);
  2342.     DEBUGMSGTL(("mteTriggerTable",
  2343.                 "write_mteTriggerObjectsOwner entering action=%d...  n",
  2344.                 action));
  2345.     if ((StorageTmp =
  2346.          header_complex(mteTriggerTableStorage, NULL,
  2347.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2348.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2349.                         NULL)) == NULL)
  2350.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2353.     switch (action) {
  2354.     case RESERVE1:
  2355.         if (var_val_type != ASN_OCTET_STR) {
  2356.             snmp_log(LOG_ERR,
  2357.                      "write to mteTriggerObjectsOwner not ASN_OCTET_STRn");
  2358.             return SNMP_ERR_WRONGTYPE;
  2359.         }
  2360.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2361.             return SNMP_ERR_NOTWRITABLE;
  2362.         break;
  2365.     case RESERVE2:
  2366.         /*
  2367.          * memory reseveration, final preparation... 
  2368.          */
  2369.         break;
  2372.     case FREE:
  2373.         /*
  2374.          * Release any resources that have been allocated 
  2375.          */
  2376.         break;
  2379.     case ACTION:
  2380.         /*
  2381.          * The variable has been stored in string for
  2382.          * you to use, and you have just been asked to do something with
  2383.          * it.  Note that anything done here must be reversable in the UNDO case 
  2384.          */
  2385.         tmpvar = StorageTmp->mteTriggerObjectsOwner;
  2386.         tmplen = StorageTmp->mteTriggerObjectsOwnerLen;
  2387.         memdup((u_char **) & StorageTmp->mteTriggerObjectsOwner, var_val,
  2388.                var_val_len);
  2389.         StorageTmp->mteTriggerObjectsOwnerLen = var_val_len;
  2390.         break;
  2393.     case UNDO:
  2394.         /*
  2395.          * Back out any changes made in the ACTION case 
  2396.          */
  2397.         SNMP_FREE(StorageTmp->mteTriggerObjectsOwner);
  2398.         StorageTmp->mteTriggerObjectsOwner = tmpvar;
  2399.         StorageTmp->mteTriggerObjectsOwnerLen = tmplen;
  2400.         break;
  2403.     case COMMIT:
  2404.         /*
  2405.          * Things are working well, so it's now safe to make the change
  2406.          * permanently.  Make sure that anything done here can't fail! 
  2407.          */
  2408.         SNMP_FREE(tmpvar);
  2409.         break;
  2410.     }
  2411.     return SNMP_ERR_NOERROR;
  2412. }
  2416. int
  2417. write_mteTriggerObjects(int action,
  2418.                         u_char * var_val,
  2419.                         u_char var_val_type,
  2420.                         size_t var_val_len,
  2421.                         u_char * statP, oid * name, size_t name_len)
  2422. {
  2423.     static char    *tmpvar;
  2424.     struct mteTriggerTable_data *StorageTmp = NULL;
  2425.     static size_t   tmplen;
  2426.     size_t          newlen =
  2427.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2428.                     3 - 1);
  2431.     DEBUGMSGTL(("mteTriggerTable",
  2432.                 "write_mteTriggerObjects entering action=%d...  n",
  2433.                 action));
  2434.     if ((StorageTmp =
  2435.          header_complex(mteTriggerTableStorage, NULL,
  2436.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2437.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2438.                         NULL)) == NULL)
  2439.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2442.     switch (action) {
  2443.     case RESERVE1:
  2444.         if (var_val_type != ASN_OCTET_STR) {
  2445.             snmp_log(LOG_ERR,
  2446.                      "write to mteTriggerObjects not ASN_OCTET_STRn");
  2447.             return SNMP_ERR_WRONGTYPE;
  2448.         }
  2449.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2450.             return SNMP_ERR_NOTWRITABLE;
  2451.         break;
  2454.     case RESERVE2:
  2455.         /*
  2456.          * memory reseveration, final preparation... 
  2457.          */
  2458.         break;
  2461.     case FREE:
  2462.         /*
  2463.          * Release any resources that have been allocated 
  2464.          */
  2465.         break;
  2468.     case ACTION:
  2469.         /*
  2470.          * The variable has been stored in string for
  2471.          * you to use, and you have just been asked to do something with
  2472.          * it.  Note that anything done here must be reversable in the UNDO case 
  2473.          */
  2474.         tmpvar = StorageTmp->mteTriggerObjects;
  2475.         tmplen = StorageTmp->mteTriggerObjectsLen;
  2476.         memdup((u_char **) & StorageTmp->mteTriggerObjects, var_val,
  2477.                var_val_len);
  2478.         StorageTmp->mteTriggerObjectsLen = var_val_len;
  2479.         break;
  2482.     case UNDO:
  2483.         /*
  2484.          * Back out any changes made in the ACTION case 
  2485.          */
  2486.         SNMP_FREE(StorageTmp->mteTriggerObjects);
  2487.         StorageTmp->mteTriggerObjects = tmpvar;
  2488.         StorageTmp->mteTriggerObjectsLen = tmplen;
  2489.         break;
  2492.     case COMMIT:
  2493.         /*
  2494.          * Things are working well, so it's now safe to make the change
  2495.          * permanently.  Make sure that anything done here can't fail! 
  2496.          */
  2497.         SNMP_FREE(tmpvar);
  2498.         break;
  2499.     }
  2500.     return SNMP_ERR_NOERROR;
  2501. }
  2505. int
  2506. write_mteTriggerEnabled(int action,
  2507.                         u_char * var_val,
  2508.                         u_char var_val_type,
  2509.                         size_t var_val_len,
  2510.                         u_char * statP, oid * name, size_t name_len)
  2511. {
  2512.     static int      tmpvar;
  2513.     struct mteTriggerTable_data *StorageTmp = NULL;
  2514.     size_t          newlen =
  2515.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2516.                     3 - 1);
  2519.     DEBUGMSGTL(("mteTriggerTable",
  2520.                 "write_mteTriggerEnabled entering action=%d...  n",
  2521.                 action));
  2522.     if ((StorageTmp =
  2523.          header_complex(mteTriggerTableStorage, NULL,
  2524.                         &name[sizeof(mteTriggerTable_variables_oid) /
  2525.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  2526.                         NULL)) == NULL)
  2527.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  2530.     switch (action) {
  2531.     case RESERVE1:
  2532.         if (var_val_type != ASN_INTEGER) {
  2533.             snmp_log(LOG_ERR,
  2534.                      "write to mteTriggerEnabled not ASN_INTEGERn");
  2535.             return SNMP_ERR_WRONGTYPE;
  2536.         }
  2537.         if (StorageTmp->storageType != ST_NONVOLATILE)
  2538.             return SNMP_ERR_NOTWRITABLE;
  2539.         break;
  2542.     case RESERVE2:
  2543.         /*
  2544.          * memory reseveration, final preparation... 
  2545.          */
  2546.         break;
  2549.     case FREE:
  2550.         /*
  2551.          * Release any resources that have been allocated 
  2552.          */
  2553.         break;
  2556.     case ACTION:
  2557.         /*
  2558.          * The variable has been stored in long_ret for
  2559.          * you to use, and you have just been asked to do something with
  2560.          * it.  Note that anything done here must be reversable in the UNDO case 
  2561.          */
  2562.         tmpvar = StorageTmp->mteTriggerEnabled;
  2563.         StorageTmp->mteTriggerEnabled = *((long *) var_val);
  2564.         break;
  2567.     case UNDO:
  2568.         /*
  2569.          * Back out any changes made in the ACTION case 
  2570.          */
  2571.         StorageTmp->mteTriggerEnabled = tmpvar;
  2572.         break;
  2575.     case COMMIT:
  2576.         /*
  2577.          * Things are working well, so it's now safe to make the change
  2578.          * permanently.  Make sure that anything done here can't fail! 
  2579.          */
  2580.         if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
  2581.             StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
  2582.             mte_enable_trigger(StorageTmp);
  2583.         else if (StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_FALSE)
  2584.             mte_disable_trigger(StorageTmp);
  2587.         break;
  2588.     }
  2589.     return SNMP_ERR_NOERROR;
  2590. }
  2597. int
  2598. write_mteTriggerEntryStatus(int action,
  2599.                             u_char * var_val,
  2600.                             u_char var_val_type,
  2601.                             size_t var_val_len,
  2602.                             u_char * statP, oid * name, size_t name_len)
  2603. {
  2604.     struct mteTriggerTable_data *StorageTmp = NULL;
  2605.     static struct mteTriggerTable_data *StorageNew, *StorageDel;
  2606.     size_t          newlen =
  2607.         name_len - (sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2608.                     3 - 1);
  2609.     static int      old_value;
  2610.     int             set_value;
  2611.     static netsnmp_variable_list *vars, *vp;
  2612.     struct header_complex_index *hciptr;
  2614.     StorageTmp =
  2615.         header_complex(mteTriggerTableStorage, NULL,
  2616.                        &name[sizeof(mteTriggerTable_variables_oid) /
  2617.                              sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
  2622.     if (var_val_type != ASN_INTEGER || var_val == NULL) {
  2623.         snmp_log(LOG_ERR,
  2624.                  "write to mteTriggerEntryStatus not ASN_INTEGERn");
  2625.         return SNMP_ERR_WRONGTYPE;
  2626.     }
  2627.     set_value = *((long *) var_val);
  2630.     /*
  2631.      * check legal range, and notReady is reserved for us, not a user 
  2632.      */
  2633.     if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
  2634.         return SNMP_ERR_INCONSISTENTVALUE;
  2637.     switch (action) {
  2638.     case RESERVE1:
  2639.         /*
  2640.          * stage one: test validity 
  2641.          */
  2642.         if (StorageTmp == NULL) {
  2643.             /*
  2644.              * create the row now? 
  2645.              */
  2648.             /*
  2649.              * ditch illegal values now 
  2650.              */
  2651.             if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE)
  2652.                 return SNMP_ERR_INCONSISTENTVALUE;
  2655.             /*
  2656.              * destroying a non-existent row is actually legal 
  2657.              */
  2658.             if (set_value == RS_DESTROY) {
  2659.                 return SNMP_ERR_NOERROR;
  2660.             }
  2663.             /*
  2664.              * illegal creation values 
  2665.              */
  2666.             if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
  2667.                 return SNMP_ERR_INCONSISTENTVALUE;
  2668.             }
  2669.         } else {
  2670.             /*
  2671.              * row exists.  Check for a valid state change 
  2672.              */
  2673.             if (set_value == RS_CREATEANDGO
  2674.                 || set_value == RS_CREATEANDWAIT) {
  2675.                 /*
  2676.                  * can't create a row that exists 
  2677.                  */
  2678.                 return SNMP_ERR_INCONSISTENTVALUE;
  2679.             }
  2681.             if (StorageTmp->mteTriggerEntryStatus == RS_ACTIVE &&
  2682.                 set_value != RS_DESTROY) {
  2683.                 /*
  2684.                  * "Once made active an entry may not be modified except to 
  2685.                  * delete it."  XXX: doesn't this in fact apply to ALL
  2686.                  * columns of the table and not just this one?  
  2687.                  */
  2688.                 return SNMP_ERR_INCONSISTENTVALUE;
  2689.             }
  2690.             if (StorageTmp->storageType != ST_NONVOLATILE)
  2691.                 return SNMP_ERR_NOTWRITABLE;
  2692.         }
  2693.         break;
  2698.     case RESERVE2:
  2699.         /*
  2700.          * memory reseveration, final preparation... 
  2701.          */
  2702.         if (StorageTmp == NULL) {
  2703.             /*
  2704.              * creation 
  2705.              */
  2706.             vars = NULL;
  2709.             snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0);  /* mteOwner */
  2710.             snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, NULL, 0);     /* mteTriggerName */
  2714.             if (header_complex_parse_oid
  2715.                 (&
  2716.                  (name
  2717.                   [sizeof(mteTriggerTable_variables_oid) / sizeof(oid) +
  2718.                    2]), newlen, vars) != SNMPERR_SUCCESS) {
  2719.                 /*
  2720.                  * XXX: free, zero vars 
  2721.                  */
  2722.                 return SNMP_ERR_INCONSISTENTNAME;
  2723.             }
  2724.             vp = vars;
  2727.             StorageNew = create_mteTriggerTable_data();
  2729.             StorageNew->mteOwner = malloc(vp->val_len + 1);
  2730.             memcpy(StorageNew->mteOwner, vp->val.string, vp->val_len);
  2731.             StorageNew->mteOwner[vp->val_len] = '';
  2732.             StorageNew->mteOwnerLen = vp->val_len;
  2734.             vp = vp->next_variable;
  2735.             StorageNew->mteTriggerName = malloc(vp->val_len + 1);
  2736.             memcpy(StorageNew->mteTriggerName, vp->val.string,
  2737.                    vp->val_len);
  2738.             StorageNew->mteTriggerName[vp->val_len] = '';
  2739.             StorageNew->mteTriggerNameLen = vp->val_len;
  2741.             vp = vp->next_variable;
  2743.             StorageNew->mteTriggerEntryStatus = set_value;
  2745.         }
  2748.         break;
  2753.     case FREE:
  2754.         /*
  2755.          * XXX: free, zero vars 
  2756.          */
  2757.         /*
  2758.          * Release any resources that have been allocated 
  2759.          */
  2760.         break;
  2765.     case ACTION:
  2766.         /*
  2767.          * The variable has been stored in set_value for you to
  2768.          * use, and you have just been asked to do something with
  2769.          * it.  Note that anything done here must be reversable in
  2770.          * the UNDO case 
  2771.          */
  2774.         if (StorageTmp == NULL) {
  2775.             /*
  2776.              * row creation, so add it 
  2777.              */
  2778.             if (StorageNew != NULL)
  2779.                 mteTriggerTable_add(StorageNew);
  2780.             /*
  2781.              * XXX: ack, and if it is NULL? 
  2782.              */
  2783.         } else if (set_value != RS_DESTROY) {
  2784.             /*
  2785.              * set the flag? 
  2786.              */
  2787.             old_value = StorageTmp->mteTriggerEntryStatus;
  2788.             StorageTmp->mteTriggerEntryStatus = *((long *) var_val);
  2789.         } else {
  2790.             /*
  2791.              * destroy...  extract it for now 
  2792.              */
  2793.             hciptr =
  2794.                 header_complex_find_entry(mteTriggerTableStorage,
  2795.                                           StorageTmp);
  2796.             StorageDel =
  2797.                 header_complex_extract_entry(&mteTriggerTableStorage,
  2798.                                              hciptr);
  2799.         }
  2800.         break;
  2805.     case UNDO:
  2806.         /*
  2807.          * Back out any changes made in the ACTION case 
  2808.          */
  2809.         if (StorageTmp == NULL) {
  2810.             /*
  2811.              * row creation, so remove it again 
  2812.              */
  2813.             hciptr =
  2814.                 header_complex_find_entry(mteTriggerTableStorage,
  2815.                                           StorageTmp);
  2816.             StorageDel =
  2817.                 header_complex_extract_entry(&mteTriggerTableStorage,
  2818.                                              hciptr);
  2819.             /*
  2820.              * XXX: free it 
  2821.              */
  2822.         } else if (StorageDel != NULL) {
  2823.             /*
  2824.              * row deletion, so add it again 
  2825.              */
  2826.             mteTriggerTable_add(StorageDel);
  2827.         } else {
  2828.             StorageTmp->mteTriggerEntryStatus = old_value;
  2829.         }
  2830.         break;
  2835.     case COMMIT:
  2836.         /*
  2837.          * Things are working well, so it's now safe to make the change
  2838.          * permanently.  Make sure that anything done here can't fail! 
  2839.          */
  2840.         if (StorageDel != NULL) {
  2841.             mte_disable_trigger(StorageDel);
  2842.             StorageDel = 0;
  2843.             /*
  2844.              * XXX: free it, its dead 
  2845.              */
  2846.         } else {
  2847.             if (StorageTmp
  2848.                 && StorageTmp->mteTriggerEntryStatus == RS_CREATEANDGO) {
  2849.                 StorageTmp->mteTriggerEntryStatus = RS_ACTIVE;
  2850.             } else if (StorageTmp &&
  2851.                        StorageTmp->mteTriggerEntryStatus ==
  2852.                        RS_CREATEANDWAIT) {
  2853.                 StorageTmp->mteTriggerEntryStatus = RS_NOTINSERVICE;
  2854.             }
  2855.         }
  2856.         if (StorageTmp &&
  2857.             StorageTmp->mteTriggerEntryStatus == RS_ACTIVE &&
  2858.             !StorageTmp->have_copied_auth_info) {
  2860.             netsnmp_agent_session *asp =
  2861.                 netsnmp_get_current_agent_session();
  2862.             netsnmp_pdu    *pdu = NULL;
  2864.             if (!asp) {
  2865.                 snmp_log(LOG_ERR,
  2866.                          "snmpTriggerTable: can't get master session for authentication paramsn");
  2867.             } else {
  2868.                 pdu = asp->orig_pdu;
  2869.                 if (!pdu) {
  2870.                     snmp_log(LOG_ERR,
  2871.                              "snmpTriggerTable: can't get master pdu for authentication paramsn");
  2872.                 }
  2873.             }
  2875.             if (pdu) {
  2876.                 DEBUGMSGTL(("mteTriggerTest", "copying PDU auth infon"));
  2877.                 StorageTmp->pdu_version = pdu->version;
  2878.                 StorageTmp->pdu_securityModel = pdu->securityModel;
  2879.                 StorageTmp->pdu_securityLevel = pdu->securityLevel;
  2880.                 StorageTmp->pdu_tDomain = pdu->tDomain;
  2881.                 StorageTmp->pdu_tDomainLen = pdu->tDomainLen;
  2882.                 if (pdu->transport_data != NULL) {
  2883.                     StorageTmp->pdu_transport =
  2884.                         malloc(pdu->transport_data_length);
  2885.                     memcpy(StorageTmp->pdu_transport, pdu->transport_data,
  2886.                            pdu->transport_data_length);
  2887.                 }
  2888.                 StorageTmp->pdu_transportLen = pdu->transport_data_length;
  2889.                 if (pdu->community) {
  2890.                     StorageTmp->pdu_community =
  2891.                         calloc(1, pdu->community_len + 1);
  2892.                     memcpy(StorageTmp->pdu_community, pdu->community,
  2893.                            pdu->community_len);
  2894.                     StorageTmp->pdu_community_len = pdu->community_len;
  2895.                 } else {
  2896.                     StorageTmp->pdu_community = NULL;
  2897.                     StorageTmp->pdu_community_len = 0;
  2898.                 }
  2899.                 if (pdu->securityName) {
  2900.                     StorageTmp->pdu_securityName =
  2901.                         calloc(1, pdu->securityNameLen + 1);
  2902.                     memcpy(StorageTmp->pdu_securityName, pdu->securityName,
  2903.                            pdu->securityNameLen);
  2904.                     StorageTmp->pdu_securityNameLen = pdu->securityNameLen;
  2905.                 } else {
  2906.                     StorageTmp->pdu_securityName = NULL;
  2907.                     StorageTmp->pdu_securityNameLen = 0;
  2908.                 }
  2909.                 StorageTmp->have_copied_auth_info = 1;
  2910.             }
  2911.         }
  2913.         if (StorageTmp &&
  2914.             StorageTmp->mteTriggerEnabled == MTETRIGGERENABLED_TRUE &&
  2915.             StorageTmp->mteTriggerEntryStatus == RS_ACTIVE)
  2916.             mte_enable_trigger(StorageTmp);
  2917.         break;
  2918.     }
  2919.     return SNMP_ERR_NOERROR;
  2920. }
  2922. /*
  2923.  * send trap 
  2924.  */
  2925. void
  2926. send_mte_trap(struct mteTriggerTable_data *item,
  2927.               oid * trap_oid, size_t trap_oid_len,
  2928.               oid * name_oid, size_t name_oid_len,
  2929.               long *value, const char *objowner, const char *objname,
  2930.               const char *reason)
  2931. {
  2932.     static oid      objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };     /* snmpTrapIOD.0 */
  2934.     netsnmp_variable_list *var_list = NULL;
  2936.     /*
  2937.      * snmpTrap oid 
  2938.      */
  2939.     snmp_varlist_add_variable(&var_list, objid_snmptrap,
  2940.                               sizeof(objid_snmptrap) / sizeof(oid),
  2941.                               ASN_OBJECT_ID, (u_char *) trap_oid,
  2942.                               trap_oid_len * sizeof(oid));
  2944.     /*
  2945.      * mteHotTrigger 
  2946.      */
  2947.     snmp_varlist_add_variable(&var_list, mteHotTrigger,
  2948.                               sizeof(mteHotTrigger) / sizeof(oid),
  2949.                               ASN_OCTET_STR,
  2950.                               (u_char *) item->mteTriggerName,
  2951.                               item->mteTriggerNameLen);
  2953.     /*
  2954.      * mteHotTargetName 
  2955.      */
  2956.     snmp_varlist_add_variable(&var_list, mteHotTargetName, sizeof(mteHotTargetName) / sizeof(oid), ASN_OCTET_STR, (u_char *) item->mteTriggerTargetTag, /*XXX: targetName,not tag */
  2957.                               item->mteTriggerTargetTagLen);    /*XXX */
  2959.     /*
  2960.      * mteHotContextName 
  2961.      */
  2962.     snmp_varlist_add_variable(&var_list, mteHotContextName,
  2963.                               sizeof(mteHotContextName) / sizeof(oid),
  2964.                               ASN_OCTET_STR,
  2965.                               (u_char *) item->mteTriggerContextName,
  2966.                               item->mteTriggerContextNameLen);
  2968.     snmp_varlist_add_variable(&var_list, mteHotOID,
  2969.                               sizeof(mteHotOID) / sizeof(oid),
  2970.                               ASN_OBJECT_ID, (u_char *) name_oid,
  2971.                               sizeof(oid) * name_oid_len);
  2973.     if (trap_oid == mteTriggerFailure || trap_oid == mteEventSetFailure) {
  2974.         /*
  2975.          * mteFailedReason  
  2976.          */
  2977.         snmp_varlist_add_variable(&var_list, mteFailedReason,
  2978.                                   sizeof(mteFailedReason) / sizeof(oid),
  2979.                                   ASN_INTEGER, (u_char *) value,
  2980.                                   sizeof(value));
  2981.     } else {
  2982.         /*
  2983.          * mteHotValue  
  2984.          */
  2985.         snmp_varlist_add_variable(&var_list, mteHotValue,
  2986.                                   sizeof(mteHotValue) / sizeof(oid),
  2987.                                   ASN_INTEGER, (u_char *) value,
  2988.                                   sizeof(value));
  2989.     }
  2991.     /*
  2992.      * add in traps from main table 
  2993.      */
  2994.     mte_add_objects(var_list, item, item->mteTriggerObjectsOwner,
  2995.                     item->mteTriggerObjects,
  2996.                     name_oid + item->mteTriggerValueIDLen,
  2997.                     name_oid_len - item->mteTriggerValueIDLen);
  2998.     /*
  2999.      * add in traps from sub table 
  3000.      */
  3001.     mte_add_objects(var_list, item, objowner, objname,
  3002.                     name_oid + item->mteTriggerValueIDLen,
  3003.                     name_oid_len - item->mteTriggerValueIDLen);
  3005.     /*
  3006.      * XXX: stuff based on event table 
  3007.      */
  3008.     DEBUGMSGTL(("mteTriggerTest:send_mte_trap", "sending the trap (%s): ",
  3009.                 reason));
  3010.     DEBUGMSGOID(("mteTriggerTest:send_mte_trap", name_oid, name_oid_len));
  3011.     DEBUGMSG(("mteTriggerTest:send_mte_trap", " = %ldn", *value));
  3013.     send_v2trap(var_list);
  3014.     snmp_free_varbind(var_list);
  3015. }
  3017. void
  3018. last_state_clean(void *data)
  3019. {
  3020.     struct last_state *cleanme = (struct last_state *) data;
  3021.     SNMP_FREE(cleanme->value);
  3022.     SNMP_FREE(cleanme);
  3023. }
  3025. /*
  3026.  * retrieves requested info in pdu from the current target 
  3027.  */
  3028. netsnmp_pdu    *
  3029. mte_get_response(struct mteTriggerTable_data *item, netsnmp_pdu *pdu)
  3030. {
  3031.     netsnmp_pdu    *response = NULL;
  3032.     int             status = 0;
  3033.     char            buf[SPRINT_MAX_LEN];
  3035.     /*
  3036.      * local agent check 
  3037.      */
  3038.     pdu->errstat = SNMPERR_SUCCESS;
  3039.     pdu->errindex = 0;
  3040.     pdu->version = item->pdu_version;
  3041.     pdu->securityModel = item->pdu_securityModel;
  3042.     pdu->securityLevel = item->pdu_securityLevel;
  3043.     pdu->tDomain = item->pdu_tDomain;
  3044.     pdu->tDomainLen = item->pdu_tDomainLen;
  3045.     memdup((u_char **) & pdu->transport_data, item->pdu_transport,
  3046.            item->pdu_transportLen);
  3047.     pdu->transport_data_length = item->pdu_transportLen;
  3048.     memdup(&pdu->community, item->pdu_community, item->pdu_community_len);
  3049.     pdu->community_len = item->pdu_community_len;
  3050.     memdup((u_char **) & pdu->contextName, item->mteTriggerContextName,
  3051.            item->mteTriggerContextNameLen);
  3052.     pdu->contextNameLen = item->mteTriggerContextNameLen;
  3053.     memdup((u_char **) & pdu->securityName, item->pdu_securityName,
  3054.            item->pdu_securityNameLen);
  3055.     pdu->securityNameLen = item->pdu_securityNameLen;
  3056.     DEBUGMSGTL(("mteTriggerTable",
  3057.                 "accessing locally with secName "%s" community "%s"n",
  3058.                 item->pdu_securityName ? (char *) item->
  3059.                 pdu_securityName : "[NIL]",
  3060.                 item->pdu_community ? (char *) item->
  3061.                 pdu_community : "[NIL]"));
  3063.     if (item->mteTriggerTargetTagLen == 0) {
  3064.         /*
  3065.          * send to the local agent 
  3066.          */
  3068.         status = snmp_synch_response(mte_callback_sess, pdu, &response);
  3070.         if (status != SNMP_ERR_NOERROR ||
  3071.             response->errstat != SNMP_ERR_NOERROR) {
  3072.             /*
  3073.              * xxx 
  3074.              */
  3075.             char           *errstr;
  3076.             snmp_error(mte_callback_sess, 0, 0, &errstr);
  3077.             if (response) {
  3078.                 DEBUGMSGTL(("mteTriggerTable",
  3079.                             "Error received: status=%d, sess_error=%s, pduerr=%d/%s, pdu version=%dn",
  3080.                             status, errstr,
  3081.                             response->errstat,
  3082.                             snmp_api_errstring(response->errstat),
  3083.                             response->version));
  3084.             } else {
  3085.                 DEBUGMSGTL(("mteTriggerTable",
  3086.                             "Error received: status=%d, sess_error=%s [no response pointer]n",
  3087.                             status, errstr));
  3088.             }
  3089.             if (errstr)
  3090.                 free(errstr);
  3091.             return NULL;        /* XXX: proper failure, trap sent, etc */
  3092.         }
  3093.     } else {
  3094.         /*
  3095.          * remote target list 
  3096.          */
  3097.         /*
  3098.          * XXX 
  3099.          */
  3100.     }
  3101.     if (response->variables)
  3102.         snprint_variable(buf, sizeof(buf), response->variables->name,
  3103.                          response->variables->name_length,
  3104.                          response->variables);
  3105.     else
  3106.         strcpy(buf, "empty");
  3107.     buf[sizeof(buf) - 1] = '';
  3108.     DEBUGMSGTL(("mteTriggerTable", "got a variables: %sn", buf));
  3109.     return response;
  3110. }
  3113. /*
  3114.  * Return 1 if `type' is an integer type; specifically, to quote RFC 2981,
  3115.  * p. 13, "anything that ends up encoded for transmission (that is, in BER,
  3116.  * not ASN.1) as an integer".  Return 0 for all other types.  
  3117.  */
  3119. int
  3120. mte_is_integer_type(unsigned char type)
  3121. {
  3122.     switch (type) {
  3123.     case ASN_INTEGER:
  3124.     case ASN_COUNTER:
  3125.     case ASN_GAUGE:
  3126.     case ASN_TIMETICKS:
  3127.     case ASN_UINTEGER:
  3128.     case ASN_COUNTER64:
  3129. #ifdef OPAQUE_SPECIAL_TYPES
  3130.     case ASN_OPAQUE_COUNTER64:
  3131.     case ASN_OPAQUE_U64:
  3132.     case ASN_OPAQUE_I64:
  3133. #endif                          /* OPAQUE_SPECIAL_TYPES */
  3134.         return 1;
  3135.     default:
  3136.         return 0;
  3137.     }
  3138. }
  3142. /*
  3143.  * Return 0 if the discontinuity object was checked and no discontinuity has
  3144.  * occurred, 1 if the discontinuity object was checked and a discontinuity
  3145.  * has occurred or -1 if the discontinuity object is not accessible.  
  3146.  */
  3148. int
  3149. mte_discontinuity_occurred(struct mteTriggerTable_data *item)
  3150. {
  3151.     netsnmp_pdu    *pdu = NULL, *response = NULL;
  3152.     unsigned long   discoTicks = 0;     /*  cool var name  */
  3154.     if (item->mteTriggerDeltaDiscontinuityIDLen == 0 ||
  3155.         (snmp_oid_compare(item->mteTriggerDeltaDiscontinuityID,
  3156.                           item->mteTriggerDeltaDiscontinuityIDLen,
  3157.                           sysUpTimeInstance,
  3158.                           sizeof(sysUpTimeInstance) / sizeof(oid)) == 0)) {
  3159.         DEBUGMSGTL(("mte_disco",
  3160.                     "discoID either zero-length or sysUpTimeInstancen"));
  3161.     } else {
  3162.         if (item->mteTriggerValueIDWildcard == TV_TRUE) {
  3163.             pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
  3164.         } else {
  3165.             pdu = snmp_pdu_create(SNMP_MSG_GET);
  3166.         }
  3167.         snmp_add_null_var(pdu, item->mteTriggerDeltaDiscontinuityID,
  3168.                           item->mteTriggerDeltaDiscontinuityIDLen);
  3169.         response = mte_get_response(item, pdu);
  3170.         if (response == NULL) {
  3171.             /*
  3172.              * XXX:  send a mteTriggerFailure notification with the appropriate
  3173.              * error code here.  
  3174.              */
  3175.             /*
  3176.              * "If the object identified is not accessible the sample attempt is in 
  3177.              * error, with the error code as from an SNMP request."  
  3178.              */
  3179.             DEBUGMSGTL(("mte_disco", "failure (auth?) getting discoIDn"));
  3180.             return -1;
  3181.         } else {
  3182.             if (item->mteTriggerDeltaDiscontinuityIDType ==
  3183.                 MTETRIGGERDELTADISCONTINUITYIDTYPE_TIMETICKS ||
  3184.                 item->mteTriggerDeltaDiscontinuityIDType ==
  3185.                 MTETRIGGERDELTADISCONTINUITYIDTYPE_TIMESTAMP) {
  3186.                 if (response->errstat == SNMPERR_SUCCESS) {
  3187.                     if (response->variables != NULL &&
  3188.                         response->variables->type == ASN_TIMETICKS) {
  3189.                         DEBUGMSGTL(("mte_disco",
  3190.                                     "got ASN_TIMETICKS-valued variablen"));
  3191.                         discoTicks =
  3192.                             *((unsigned long *) response->variables->val.
  3193.                               integer);
  3194.                         if (item->prevDiscoTicks != 0) {
  3195.                             if (discoTicks != item->prevDiscoTicks) {
  3196.                                 /*
  3197.                                  * Danger Will Robinson: there has been a discontinuity!  
  3198.                                  */
  3199.                                 DEBUGMSGTL(("mte_disco",
  3200.                                             "a discontinuity has occurredn"));
  3201.                                 item->prevDiscoTicks = discoTicks;
  3202.                                 snmp_free_pdu(response);
  3203.                                 return 1;
  3204.                             }
  3205.                         }
  3206.                         item->prevDiscoTicks = discoTicks;
  3207.                     } else {
  3208.                         /*
  3209.                          * XXX: send a mteTriggerFailure notification with the
  3210.                          * appropriate error code here.  
  3211.                          */
  3212.                         if (response->variables != NULL &&
  3213.                             (response->variables->type == SNMP_NOSUCHOBJECT
  3214.                              || response->variables->type ==
  3215.                              SNMP_NOSUCHINSTANCE
  3216.                              || response->variables->type ==
  3217.                              SNMP_ENDOFMIBVIEW)) {
  3218.                             /*
  3219.                              * noSuchName I guess.  
  3220.                              */
  3221.                         } else {
  3222.                             /*
  3223.                              * badType.  
  3224.                              */
  3225.                         }
  3226.                         DEBUGMSGTL(("mte_disco",
  3227.                                     "failure getting discoIDn"));
  3228.                         snmp_free_pdu(response);
  3229.                         return -1;
  3230.                     }
  3231.                 } else {
  3232.                     /*
  3233.                      * XXX: send a mteTriggerFailure notification with the appropriate
  3234.                      * error code (just use response->errstat) here.  
  3235.                      */
  3236.                     DEBUGMSGTL(("mte_disco", "failure getting discoIDn"));
  3237.                     snmp_free_pdu(response);
  3238.                     return -1;
  3239.                 }
  3240.             } else {
  3241.                 /*
  3242.                  * Don't handle dateAndTime type queries yet.  
  3243.                  */
  3244.                 DEBUGMSGTL(("mte_disco",
  3245.                             "dateAndTime query UNIMPLEMENTEDn"));
  3246.             }
  3247.             snmp_free_pdu(response);
  3248.         }
  3249.     }
  3251.     /*
  3252.      * "...if this object does not point to sysUpTime discontinuity checking
  3253.      * MUST still check sysUpTime for an overall discontinuity."  
  3254.      */
  3255.     if (snmp_oid_compare(item->mteTriggerDeltaDiscontinuityID,
  3256.                          item->mteTriggerDeltaDiscontinuityIDLen,
  3257.                          sysUpTimeInstance,
  3258.                          sizeof(sysUpTimeInstance) / sizeof(oid)) != 0) {
  3259.         DEBUGMSGTL(("mte_disco", "discoID != sysUpTimeInstancen"));
  3260.         /*
  3261.          * At the moment we only support checking the local system so there's no
  3262.          * point doing anything extra here.  
  3263.          */
  3264.     }
  3266.     /*
  3267.      * Well if we got all the way to here, then there has been neither a
  3268.      * discontinuity nor an error.  
  3269.      */
  3270.     DEBUGMSGTL(("mte_disco", "no discontinuityn"));
  3271.     return 0;
  3272. }
  3275. void
  3276. mte_run_trigger(unsigned int clientreg, void *clientarg)
  3277. {
  3279.     struct mteTriggerTable_data *item =
  3280.         (struct mteTriggerTable_data *) clientarg;
  3281.     netsnmp_pdu    *pdu = NULL, *response = NULL;
  3282.     char            buf[SPRINT_MAX_LEN];
  3283.     int             msg_type = SNMP_MSG_GET, disco;
  3285.     oid            *next_oid;
  3286.     size_t          next_oid_len;
  3287.     long           *value, *old_value, x;
  3288.     struct last_state *laststate;
  3289.     char            lastbool = 0, boolresult = 0, lastthresh = 0, senttrap = 0;
  3291.     if (!item) {
  3292.         /*
  3293.          * ack 
  3294.          */
  3295.         snmp_alarm_unregister(clientreg);
  3296.         return;
  3297.     }
  3298.     DEBUGMSGTL(("mteTriggertable", "Running trigger for %s/%sn",
  3299.                 item->mteOwner, item->mteTriggerName));
  3301.     next_oid = item->mteTriggerValueID;
  3302.     next_oid_len = item->mteTriggerValueIDLen;
  3303.     if (item->mteTriggerValueIDWildcard == TV_TRUE)
  3304.         msg_type = SNMP_MSG_GETNEXT;
  3306.     item->hc_storage_old = item->hc_storage;
  3307.     item->hc_storage = NULL;
  3308.     do {
  3309.         pdu = snmp_pdu_create(msg_type);
  3310.         snmp_add_null_var(pdu, next_oid, next_oid_len);
  3311.         response = mte_get_response(item, pdu);
  3312.         if (!response)
  3313.             break;              /* XXX: proper failure */
  3315.         if (item->mteTriggerValueIDWildcard == TV_TRUE &&
  3316.             ((response->variables->type >= SNMP_NOSUCHOBJECT &&
  3317.               response->variables->type <= SNMP_ENDOFMIBVIEW) ||
  3318.              snmp_oid_compare(item->mteTriggerValueID,
  3319.                               item->mteTriggerValueIDLen,
  3320.                               response->variables->name,
  3321.                               item->mteTriggerValueIDLen) != 0)) {
  3322.             DEBUGMSGTL(("mteTriggerTable",
  3323.                         "DONE, last varbind processedn"));
  3324.             snmp_free_pdu(response);
  3325.             break;
  3326.         }
  3328.         /*
  3329.          * shorter pointers 
  3330.          */
  3331.         next_oid = response->variables->name;
  3332.         next_oid_len = response->variables->name_length;
  3334.         /*
  3335.          * Send a "bad type" notification if the type of the target object is 
  3336.          * non-INTEGER and the test type is either `boolean' or `threshold'
  3337.          * (which want to do arithmetic).  
  3338.          */
  3339.         if (((item->mteTriggerTest[0] & MTETRIGGERTEST_BOOLEAN) ||
  3340.              (item->mteTriggerTest[0] & MTETRIGGERTEST_THRESHOLD)) &&
  3341.             response->errstat == SNMPERR_SUCCESS &&
  3342.             !mte_is_integer_type(response->variables->type)) {
  3343.             long            failure = MTE_FAILURE_BADTYPE;
  3344.             send_mte_trap(item, mteTriggerFailure,
  3345.                           sizeof(mteTriggerFailure) / sizeof(oid),
  3346.                           next_oid, next_oid_len, &failure,
  3347.                           NULL, NULL, "failure: bad type");
  3348.             snmp_free_pdu(response);
  3349.             /*
  3350.              * RFC2981, p.15: "If the value syntax of those objects
  3351.              * [returned by a getNext-style match] is not usable, that
  3352.              * results in a `badType' error THAT TERMINATES THE SCAN."
  3353.              * (my emphasis).  
  3354.              */
  3355.             break;
  3356.         }
  3358.         /*
  3359.          * Clone the value.  XXX: What happens if it's an unsigned type? Or a
  3360.          * 64-bit type, or an OCTET STRING for the sake of argument.  Do
  3361.          * everything in 64-bit arithmetic perhaps?  Generate "bad type"
  3362.          * notifications for non-INTEGER cases (except for existence).  
  3363.          */
  3364.         if (response->errstat == SNMPERR_SUCCESS &&
  3365.             response->variables->val.integer)
  3366.             memdup((unsigned char **) &value,
  3367.                    (unsigned char *) response->variables->val.integer,
  3368.                    sizeof(*response->variables->val.integer));
  3369.         else
  3370.             value = NULL;
  3372.         snprint_variable(buf, sizeof(buf),
  3373.                          next_oid, next_oid_len, response->variables);
  3374.         buf[sizeof(buf) - 1] = '';
  3375.         DEBUGMSGTL(("mteTriggerTable", "received %s (type %d)n", buf,
  3376.                     response->variables->type));
  3378.         /*
  3379.          * see if we have old values for this 
  3380.          */
  3381.         laststate = header_complex_get_from_oid(item->hc_storage_old,
  3382.                                                 next_oid, next_oid_len);
  3383.         if (laststate) {
  3384.             old_value = laststate->value;
  3385.             lastbool = laststate->lastbool;
  3386.             lastthresh = laststate->lastthreshold;
  3387.         } else {
  3388.             old_value = NULL;
  3389.             lastthresh = MTE_THRESHOLD_BEGIN;
  3390.         }
  3392.         /*
  3393.          * deal with existence tests 
  3394.          */
  3395.         if (item->mteTriggerTest[0] & MTETRIGGERTEST_EXISTENCE) {
  3396.             if ((item->mteTriggerExistenceTest[0] &
  3397.                  MTETRIGGEREXISTENCETEST_PRESENT)
  3398.                 && value && !old_value &&
  3399.                 (item->started ||
  3400.                  (item->mteTriggerExistenceStartup[0] &
  3401.                   MTETRIGGEREXISTENCESTARTUP_PRESENT))) {
  3402.                 /*
  3403.                  * XXX: if mteTriggerExistenceTest is not "present", for
  3404.                  * example, and then turned on when has been previously
  3405.                  * off, do we respect the value of the last known
  3406.                  * existence status? 
  3407.                  */
  3408.                 send_mte_trap(item, mteTriggerFired,
  3409.                               sizeof(mteTriggerFired) / sizeof(oid),
  3410.                               next_oid, next_oid_len,
  3411.                               value, item->mteTriggerExistenceObjectsOwner,
  3412.                               item->mteTriggerExistenceObjects,
  3413.                               "existence: present");
  3414.                 run_mte_events(item, next_oid, next_oid_len,
  3415.                                item->mteTriggerExistenceEventOwner,
  3416.                                item->mteTriggerExistenceEvent);
  3417.                 senttrap = 1;
  3418.             }
  3420.             if ((item->mteTriggerExistenceTest[0] &
  3421.                  MTETRIGGEREXISTENCETEST_CHANGED)
  3422.                 && value && old_value && *old_value != *value) {
  3423.                 /*
  3424.                  * XXX: if mteTriggerExistenceTest is not "present", for
  3425.                  * example, and then turned on when has been previously
  3426.                  * off, do we respect the value of the last known
  3427.                  * existence status? 
  3428.                  */
  3429.                 send_mte_trap(item, mteTriggerFired,
  3430.                               sizeof(mteTriggerFired) / sizeof(oid),
  3431.                               next_oid, next_oid_len,
  3432.                               value, item->mteTriggerExistenceObjectsOwner,
  3433.                               item->mteTriggerExistenceObjects,
  3434.                               "existence: changed");
  3435.                 run_mte_events(item, next_oid, next_oid_len,
  3436.                                item->mteTriggerExistenceEventOwner,
  3437.                                item->mteTriggerExistenceEvent);
  3438.                 senttrap = 1;
  3439.             }
  3440.         }
  3442.         /*
  3443.          * Deal with boolean tests.  
  3444.          */
  3445.         if ((item->mteTriggerTest[0] & MTETRIGGERTEST_BOOLEAN) &&
  3446.             ((item->mteTriggerSampleType ==
  3447.               MTETRIGGERSAMPLETYPE_ABSOLUTEVALUE && value)
  3448.              || (item->mteTriggerSampleType ==
  3449.                  MTETRIGGERSAMPLETYPE_DELTAVALUE && value && old_value))) {
  3450.             if (item->mteTriggerSampleType ==
  3451.                 MTETRIGGERSAMPLETYPE_DELTAVALUE) {
  3452.                 /*
  3453.                  * XXX: Must check the discontinuity OID here.  
  3454.                  */
  3455.                 disco = mte_discontinuity_occurred(item);
  3456.                 if (disco == -1) {
  3457.                     /*
  3458.                      * An error notification has already been sent; just bail
  3459.                      * out now.  
  3460.                      */
  3461.                     /*
  3462.                      * XXX: should save values here?  
  3463.                      */
  3464.                     return;
  3465.                 } else if (disco == 1) {
  3466.                     /*
  3467.                      * A discontinuity has occurred; the right thing to do here
  3468.                      * depends on the exact type.  FOR NOW, assume long.  
  3469.                      */
  3470.                     x = *((long *) value) + (INT_MAX -
  3471.                                              *((long *) old_value));
  3472.                 } else {
  3473.                     x = *((long *) value) - *((long *) old_value);
  3474.                 }
  3475.             } else {
  3476.                 x = *((long *) value);
  3477.             }
  3479.             switch (item->mteTriggerBooleanComparison) {
  3480.             case MTETRIGGERBOOLEANCOMPARISON_UNEQUAL:
  3481.                 boolresult = (x != item->mteTriggerBooleanValue);
  3482.                 break;
  3484.             case MTETRIGGERBOOLEANCOMPARISON_EQUAL:
  3485.                 boolresult = (x == item->mteTriggerBooleanValue);
  3486.                 break;
  3488.             case MTETRIGGERBOOLEANCOMPARISON_LESS:
  3489.                 boolresult = (x < item->mteTriggerBooleanValue);
  3490.                 break;
  3492.             case MTETRIGGERBOOLEANCOMPARISON_LESSOREQUAL:
  3493.                 boolresult = (x <= item->mteTriggerBooleanValue);
  3494.                 break;
  3496.             case MTETRIGGERBOOLEANCOMPARISON_GREATER:
  3497.                 boolresult = (x > item->mteTriggerBooleanValue);
  3498.                 break;
  3500.             case MTETRIGGERBOOLEANCOMPARISON_GREATEROREQUAL:
  3501.                 boolresult = (x >= item->mteTriggerBooleanValue);
  3502.                 break;
  3504.             default:
  3505.                 snmp_log(LOG_WARNING,
  3506.                          "illegal value in mteTriggerBooleanComparison object: %ld",
  3507.                          item->mteTriggerBooleanComparison);
  3508.                 boolresult = item->lastboolresult;      /* to fail next test */
  3509.             }
  3511.             if (boolresult &&
  3512.                 ((item->mteTriggerBooleanStartup ==
  3513.                   MTETRIGGERBOOLEANSTARTUP_TRUE
  3514.                   && lastbool == (char)-1) || lastbool != boolresult)) {
  3515.                 send_mte_trap(item, mteTriggerFired,
  3516.                               sizeof(mteTriggerFired) / sizeof(oid),
  3517.                               next_oid, next_oid_len,
  3518.                               &x, item->mteTriggerBooleanObjectsOwner,
  3519.                               item->mteTriggerBooleanObjects,
  3520.                               "boolean: true");
  3521.                 run_mte_events(item, next_oid, next_oid_len,
  3522.                                item->mteTriggerBooleanEventOwner,
  3523.                                item->mteTriggerBooleanEvent);
  3524.                 senttrap = 1;
  3525.             }
  3527.             DEBUGMSGTL(("mteTriggerTable",
  3528.                         "value: %d %ld %lu x: %d %ld %lun", *value,
  3529.                         *value, *value, x, x, x));
  3531.             DEBUGMSGTL(("mteTriggerTable",
  3532.                         "boolean result: x=%d %s configured=%d = %dn",
  3533.                         x,
  3534.                         se_find_label_in_slist("mteBooleanOperators",
  3535.                                                item->
  3536.                                                mteTriggerBooleanComparison),
  3537.                         item->mteTriggerBooleanValue, boolresult));
  3538.         }
  3540.         /*
  3541.          * Deal with threshold tests.  XXX: doesn't handle "delta-type"
  3542.          * sampling.  
  3543.          */
  3544.         if ((item->mteTriggerTest[0] & MTETRIGGERTEST_THRESHOLD) &&
  3545.             ((item->mteTriggerSampleType ==
  3546.               MTETRIGGERSAMPLETYPE_ABSOLUTEVALUE && value)
  3547.              || (item->mteTriggerSampleType ==
  3548.                  MTETRIGGERSAMPLETYPE_DELTAVALUE && value && old_value))) {
  3549.             /*
  3550.              * XXX: correct intepretation of mteTriggerThresholdStartup? 
  3551.              */
  3552.             /*
  3553.              * only fires when passed and just set to active?  What
  3554.              * about a newly discovered node that is past a
  3555.              * threshold once we've been active for a turn at least? 
  3556.              */
  3557.             /*
  3558.              * XXX: Check notions of > vs >= 
  3559.              */
  3560.             if (((item->started == MTE_STARTED && laststate &&
  3561.                   lastthresh == MTE_THRESHOLD_LOW) ||
  3562.                  (item->started != MTE_STARTED &&
  3563.                   (item->mteTriggerThresholdStartup ==
  3564.                    MTETRIGGERTHRESHOLDSTARTUP_RISING
  3565.                    || item->mteTriggerThresholdStartup ==
  3566.                    MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING)))
  3567.                 && (*value >= item->mteTriggerThresholdRising)) {
  3568.                 send_mte_trap(item, mteTriggerRising,
  3569.                               sizeof(mteTriggerRising) / sizeof(oid),
  3570.                               next_oid, next_oid_len, value,
  3571.                               item->mteTriggerThresholdObjectsOwner,
  3572.                               item->mteTriggerThresholdObjects,
  3573.                               "threshold: rising");
  3574.                 run_mte_events(item, next_oid, next_oid_len,
  3575.                                item->mteTriggerThresholdRisingEventOwner,
  3576.                                item->mteTriggerThresholdRisingEvent);
  3577.                 senttrap = 1;
  3578.             }
  3579.             if (((item->started == MTE_STARTED && laststate &&
  3580.                   lastthresh == MTE_THRESHOLD_HIGH) ||
  3581.                  (item->started != MTE_STARTED &&
  3582.                   (item->mteTriggerThresholdStartup ==
  3583.                    MTETRIGGERTHRESHOLDSTARTUP_FALLING
  3584.                    || item->mteTriggerThresholdStartup ==
  3585.                    MTETRIGGERTHRESHOLDSTARTUP_RISINGORFALLING)))
  3586.                 && (*value <= item->mteTriggerThresholdFalling)) {
  3587.                 send_mte_trap(item, mteTriggerFalling,
  3588.                               sizeof(mteTriggerFalling) / sizeof(oid),
  3589.                               next_oid, next_oid_len, value,
  3590.                               item->mteTriggerThresholdObjectsOwner,
  3591.                               item->mteTriggerThresholdObjects,
  3592.                               "threshold: falling");
  3593.                 run_mte_events(item, next_oid, next_oid_len,
  3594.                                item->mteTriggerThresholdFallingEventOwner,
  3595.                                item->mteTriggerThresholdFallingEvent);
  3596.                 senttrap = 1;
  3597.             }
  3599.         }
  3601.         if (value) {
  3602.             struct last_state *new_last_state =
  3603.                 SNMP_MALLOC_STRUCT(last_state);
  3604.             new_last_state->value = value;
  3605.             new_last_state->lastbool = boolresult;
  3606.             header_complex_add_data_by_oid(&item->hc_storage, next_oid,
  3607.                                            next_oid_len, new_last_state);
  3609.             /*
  3610.              * set our notion of the current known threshold state 
  3611.              */
  3612.             if (lastthresh == MTE_THRESHOLD_LOW &&
  3613.                 *value >= item->mteTriggerThresholdRising &&
  3614.                 *value > item->mteTriggerThresholdFalling)
  3615.                 new_last_state->lastthreshold = MTE_THRESHOLD_HIGH;
  3616.             else if (lastthresh == MTE_THRESHOLD_HIGH &&
  3617.                      *value < item->mteTriggerThresholdRising &&
  3618.                      *value <= item->mteTriggerThresholdFalling)
  3619.                 new_last_state->lastthreshold = MTE_THRESHOLD_LOW;
  3620.             else if (lastthresh == MTE_THRESHOLD_BEGIN) {
  3621.                 if (*value >= item->mteTriggerThresholdRising)
  3622.                     new_last_state->lastthreshold = MTE_THRESHOLD_HIGH;
  3623.                 else if (*value <= item->mteTriggerThresholdFalling)
  3624.                     new_last_state->lastthreshold = MTE_THRESHOLD_LOW;
  3625.                 /*
  3626.                  * XXX: else???  in between?  undefined? 
  3627.                  */
  3628.             } else {
  3629.                 new_last_state->lastthreshold = lastthresh;
  3630.             }
  3631.         }
  3633.         /*
  3634.          * extract from old hc storage 
  3635.          */
  3636.         if (laststate) {
  3637.             header_complex_extract_entry(&item->hc_storage_old,
  3638.                                          header_complex_find_entry(item->
  3639.                                                                    hc_storage_old,
  3640.                                                                    (void *)
  3641.                                                                    laststate));
  3642.             last_state_clean(laststate);
  3643.         }
  3645.         /*
  3646.          * We are now done with the response PDU.  
  3647.          */
  3648.         if (senttrap) 
  3649.             senttrap = 0;
  3650.         else
  3651.             snmp_free_pdu(response);
  3652.     } while (item->mteTriggerValueIDWildcard == TV_TRUE);
  3654.     /*
  3655.      * loop through old values for DNE cases 
  3656.      */
  3657.     if (item->mteTriggerExistenceTest[0] & MTETRIGGEREXISTENCETEST_ABSENT) {
  3659.         struct header_complex_index *iter;
  3661.         /*
  3662.          * XXX: broken 
  3663.          */
  3664.         if ((item->mteTriggerExistenceStartup[0] &
  3665.              MTETRIGGEREXISTENCESTARTUP_ABSENT)) {
  3666.             /*
  3667.              * XXX: send trap that nothing was found? 
  3668.              */
  3669.             /*
  3670.              * only if !wild? (see mib)
  3671.              */
  3672.         }
  3673.         for (iter = item->hc_storage_old; iter; iter = iter->next) {
  3674.             laststate = (struct last_state *) iter->data;
  3675.             send_mte_trap(item, mteTriggerFired,
  3676.                           sizeof(mteTriggerFired) / sizeof(oid),
  3677.                           iter->name, iter->namelen, laststate->value,
  3678.                           item->mteTriggerExistenceObjectsOwner,
  3679.                           item->mteTriggerExistenceObjects,
  3680.                           "existence: absent");
  3681.         }
  3682.         header_complex_free_all(item->hc_storage_old, last_state_clean);
  3683.         item->hc_storage_old = NULL;
  3684.     }
  3686.     item->started = MTE_STARTED;
  3687. }
  3690. /*
  3691.  * handling routines 
  3692.  */
  3693. void
  3694. mte_enable_trigger(struct mteTriggerTable_data *item)
  3695. {
  3696.     if (!item)
  3697.         return;
  3699.     if (item->alarmreg)
  3700.         snmp_alarm_unregister(item->alarmreg);
  3702.     if (item->mteTriggerFrequency > 0) {
  3703.         DEBUGMSGTL(("mteTriggertable", "Enabling trigger for %s/%s @ %un",
  3704.                     item->mteOwner, item->mteTriggerName,
  3705.                     item->mteTriggerFrequency));
  3706.         item->alarmreg =
  3707.             snmp_alarm_register(item->mteTriggerFrequency, SA_REPEAT,
  3708.                                 mte_run_trigger, item);
  3709.     }
  3710. }
  3712. void
  3713. mte_disable_trigger(struct mteTriggerTable_data *item)
  3714. {
  3715.     if (!item)
  3716.         return;
  3718.     if (item->alarmreg) {
  3719.         DEBUGMSGTL(("mteTriggertable", "Disabling trigger for %s/%sn",
  3720.                     item->mteOwner, item->mteTriggerName));
  3721.         snmp_alarm_unregister(item->alarmreg);
  3722.         item->alarmreg = 0;
  3723.     }
  3724.     item->started = MTE_NOTSTARTED;
  3725. }