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