Debian Codegraph @

agent/mibgroup/disman/mteTriggerTable.c

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