Debian Codegraph @

agent/mibgroup/Rmon/alarmTable.c

raw
1 /*--------------------------------------------------------------------------+
2 | Edition History: |
3 | # Date Comments By |
4 | --- -------- -------------------------------------------------------- --- |
5 | 1 07/05/18 Created. emi |
6 +--------------------------------------------------------------------------*/
7 /*
8 * Note: this file originally auto-generated by mib2c using
9 * : mib2c.table_data.conf,v 1.11.2.1 2006/01/11 15:17:47 dts12 Exp $
10 */
11
12 #include <net-snmp/net-snmp-config.h>
13 #include <net-snmp/net-snmp-features.h>
14 #include <net-snmp/net-snmp-includes.h>
15 #include <net-snmp/agent/net-snmp-agent-includes.h>
16 #include "utilities/iquery.h"
17 #include "alarmTable.h"
18 #include "event.h"
19
20 netsnmp_feature_require(iquery);
21 netsnmp_feature_require(query_set_default_session);
22 netsnmp_feature_require(table_tdata);
23 netsnmp_feature_require(check_vb_type_and_max_size);
24 netsnmp_feature_require(table_tdata_extract_table);
25 #ifndef NETSNMP_NO_WRITE_SUPPORT
26 netsnmp_feature_require(table_tdata_insert_row);
27 netsnmp_feature_require(iquery_pdu_session);
28 #endif /* NETSNMP_NO_WRITE_SUPPORT */
29
30 static netsnmp_tdata *alarm_data;
31 static netsnmp_table_registration_info *alarm_info;
32 static netsnmp_handler_registration *alarm_reg;
33
34 /** Initializes the alarmTable module */
35 void
36 init_alarmTable(void)
37 {
38 /*
39 * here we initialize all the tables we're planning on supporting
40 */
41 initialize_table_alarmTable();
42 }
43
44 /** Initialize the alarmTable table by defining its contents and how it's structured */
45 void
46 initialize_table_alarmTable(void)
47 {
48 static oid alarmTable_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1 };
49 size_t alarmTable_oid_len = OID_LENGTH(alarmTable_oid);
50
51 DEBUGMSGTL(( "rmon:alarmTable", "initialize_table_alarmTable called.\n"));
52 alarm_reg =
53 netsnmp_create_handler_registration("alarmTable",
54 alarmTable_handler,
55 alarmTable_oid,
56 alarmTable_oid_len,
57 HANDLER_CAN_RWRITE);
58
59 alarm_data = netsnmp_tdata_create_table("alarmTable", 0);
60 alarm_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
61 netsnmp_table_helper_add_indexes(alarm_info, ASN_INTEGER, /* index: alarmIndex */
62 0);
63
64 alarm_info->min_column = COLUMN_ALARMINDEX;
65 alarm_info->max_column = COLUMN_ALARMSTATUS;
66
67 netsnmp_tdata_register(alarm_reg, alarm_data, alarm_info);
68
69 /*
70 * Initialise the contents of the table here
71 */
72 }
73
74
75 void shutdown_alarmTable(void)
76 {
77 netsnmp_tdata_unregister(alarm_reg);
78 netsnmp_table_registration_info_free(alarm_info);
79 }
80
81
82 #define ALARM_STR1_LEN 32
83 typedef enum {
84 RMON1_ENTRY_VALID = 1,
85 RMON1_ENTRY_CREATE_REQUEST,
86 RMON1_ENTRY_UNDER_CREATION,
87 RMON1_ENTRY_INVALID
88 } RMON1_ENTRY_STATUS_T;
89
90 typedef enum {
91 SAMPLE_TYPE_ABSOLUTE =
92 1,
93 SAMPLE_TYPE_DELTE
94 } SAMPLE_TYPE_T;
95
96 typedef enum {
97 ALARM_NOTHING =
98 0,
99 ALARM_RISING,
100 ALARM_FALLING,
101 ALARM_BOTH
102 } ALARM_TYPE_T;
103 /*
104 * Typical data structure for a row entry
105 */
106 struct alarmTable_entry {
107 /*
108 * Index values
109 */
110 long alarmIndex;
111
112 /*
113 * Column values
114 */
115 long alarmInterval;
116 long old_alarmInterval;
117 oid alarmVariable[ALARM_STR1_LEN];
118 size_t alarmVariable_len;
119 oid old_alarmVariable[ALARM_STR1_LEN];
120 size_t old_alarmVariable_len;
121 long alarmSampleType;
122 long old_alarmSampleType;
123 long alarmValue;
124 long alarmStartupAlarm;
125 long old_alarmStartupAlarm;
126 long alarmRisingThreshold;
127 long old_alarmRisingThreshold;
128 long alarmFallingThreshold;
129 long old_alarmFallingThreshold;
130 long alarmRisingEventIndex;
131 long old_alarmRisingEventIndex;
132 long alarmFallingEventIndex;
133 long old_alarmFallingEventIndex;
134 char alarmOwner[ALARM_STR1_LEN];
135 size_t alarmOwner_len;
136 char old_alarmOwner[ALARM_STR1_LEN];
137 size_t old_alarmOwner_len;
138 long alarmStatus;
139 long old_alarmStatus;
140
141 int valid;
142 unsigned int alarm_reg;
143 netsnmp_session *session;
144 u_long last_abs_value;
145 ALARM_TYPE_T prev_alarm; /* NOTHING | RISING | FALLING */
146 };
147
148
149 void
150 alarmTable_run( unsigned int reg, void *clientarg)
151 {
152 struct alarmTable_entry *entry = (struct alarmTable_entry *)clientarg;
153 netsnmp_variable_list *var;
154 u_long new_value;
155 int rc;
156
157 if (!entry) {
158 snmp_alarm_unregister( reg );
159 return;
160 }
161 /*
162 * Retrieve the requested MIB value(s)...
163 */
164 DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_run called\n"));
165 var = (netsnmp_variable_list *)SNMP_MALLOC_TYPEDEF( netsnmp_variable_list );
166 if (!var) {
167 snmp_log(LOG_ERR,"failed to create alarmTable query varbind");
168 return;
169 }
170 snmp_set_var_objid( var, entry->alarmVariable,
171 entry->alarmVariable_len );
172
173 rc = netsnmp_query_get( var, entry->session );
174 if ( rc != SNMP_ERR_NOERROR ) {
175 DEBUGMSGTL(( "rmon:alarmTable", "alarmVariable query failed (%d)\n", rc));
176 snmp_free_varbind(var);
177 return;
178 }
179
180 switch (var->type) {
181 case ASN_INTEGER:
182 case ASN_COUNTER:
183 case ASN_TIMETICKS:
184 case ASN_GAUGE:
185 case ASN_COUNTER64:
186 new_value = *var->val.integer;
187 break;
188 default:
189 DEBUGMSGTL(("rmon:alarmTable", "invalid type (%d)\n", var->type));
190 snmp_free_varbind(var);
191 return ;
192 }
193
194 DEBUGMSGTL(("rmon:alarmTable", "alarmIndex.%ld last value (%ld)\n", entry->alarmIndex, entry->last_abs_value));
195 DEBUGMSGTL(("rmon:alarmTable", "alarmIndex.%ld new_value (%ld)\n", entry->alarmIndex, new_value));
196
197 entry->alarmValue = (SAMPLE_TYPE_ABSOLUTE == entry->alarmSampleType) ?
198 new_value : new_value - entry->last_abs_value;
199 entry->last_abs_value = new_value;
200
201 if (ALARM_RISING != entry->prev_alarm &&
202 entry->alarmValue >= entry->alarmRisingThreshold) {
203 if (SNMP_ERR_NOERROR == event_api_send_alarm(1, entry->alarmIndex,
204 entry->alarmRisingEventIndex,
205 entry->alarmVariable,
206 entry->alarmVariable_len,
207 entry->alarmSampleType,
208 entry->alarmValue,
209 entry->alarmRisingThreshold,
210 "Rising"))
211 entry->prev_alarm = ALARM_RISING;
212 else
213 snmp_log(LOG_ERR,"failed to send rising alarm\n");
214 }
215 else if (ALARM_FALLING != entry->prev_alarm &&
216 entry->alarmValue <= entry->alarmFallingThreshold) {
217 if (SNMP_ERR_NOERROR == event_api_send_alarm(0, entry->alarmIndex,
218 entry->alarmFallingEventIndex,
219 entry->alarmVariable,
220 entry->alarmVariable_len,
221 entry->alarmSampleType,
222 entry->alarmValue,
223 entry->alarmFallingThreshold,
224 "Falling"))
225 entry->prev_alarm = ALARM_FALLING;
226 else
227 snmp_log(LOG_ERR,"failed to send falling alarm\n");
228 }
229 else
230 DEBUGMSGTL(("rmon:alarmTable", "no alarm sent\n"));
231
232 snmp_free_varbind(var);
233 }
234
235 void
236 alarmTable_enable( struct alarmTable_entry *entry )
237 {
238 if (!entry)
239 return;
240
241 DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_enable called.\n"));
242 if (entry->alarm_reg) {
243 snmp_alarm_unregister( entry->alarm_reg );
244 entry->alarm_reg = 0;
245 }
246
247 if (entry->alarmInterval) {
248 /*
249 * register once to run ASAP, and another to run
250 * at the trigger frequency
251 */
252 snmp_alarm_register(0, 0, alarmTable_run, entry );
253 entry->alarm_reg = snmp_alarm_register(
254 entry->alarmInterval, SA_REPEAT,
255 alarmTable_run, entry );
256 }
257 }
258
259 void
260 alarmTable_disable( struct alarmTable_entry *entry )
261 {
262 if (!entry)
263 return;
264
265 DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_disable called.\n"));
266 if (entry->alarm_reg) {
267 snmp_alarm_unregister( entry->alarm_reg );
268 entry->alarm_reg = 0;
269 /* XXX - perhaps release any previous results */
270 }
271 }
272
273 /*
274 * create a new row in the table
275 */
276 netsnmp_tdata_row *
277 alarmTable_createEntry(netsnmp_tdata * table_data, long alarmIndex)
278 {
279 struct alarmTable_entry *entry;
280 netsnmp_tdata_row *row;
281
282 DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_createEntry called.\n"));
283 entry = SNMP_MALLOC_TYPEDEF(struct alarmTable_entry);
284 if (!entry)
285 return NULL;
286
287 row = netsnmp_tdata_create_row();
288 if (!row) {
289 SNMP_FREE(entry);
290 return NULL;
291 }
292 row->data = entry;
293 entry->alarmIndex = alarmIndex;
294 entry->alarmInterval = 1;
295 entry->alarmSampleType = SAMPLE_TYPE_ABSOLUTE;
296 entry->alarmStartupAlarm = ALARM_BOTH;
297 entry->alarmRisingThreshold = 10;
298 entry->alarmFallingThreshold = 5;
299 entry->alarmRisingEventIndex = alarmIndex;
300 entry->alarmFallingEventIndex = alarmIndex;
301 entry->prev_alarm = ALARM_NOTHING;
302 netsnmp_tdata_row_add_index(row, ASN_INTEGER,
303 &(entry->alarmIndex),
304 sizeof(entry->alarmIndex));
305 netsnmp_tdata_add_row(table_data, row);
306 return row;
307 }
308
309 /*
310 * remove a row from the table
311 */
312 void
313 alarmTable_removeEntry(netsnmp_tdata * table_data, netsnmp_tdata_row * row)
314 {
315 struct alarmTable_entry *entry;
316
317 DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_removeEntry called.\n"));
318 if (!row)
319 return; /* Nothing to remove */
320 entry = (struct alarmTable_entry *)
321 netsnmp_tdata_remove_and_delete_row(table_data, row);
322 if (entry) {
323 alarmTable_disable(entry);
324 SNMP_FREE(entry); /* XXX - release any other internal resources */
325 }
326 }
327
328
329 /** handles requests for the alarmTable table */
330 int
331 alarmTable_handler(netsnmp_mib_handler *handler,
332 netsnmp_handler_registration *reginfo,
333 netsnmp_agent_request_info *reqinfo,
334 netsnmp_request_info *requests)
335 {
336 netsnmp_request_info *request;
337 netsnmp_table_request_info *table_info;
338 netsnmp_tdata *table_data;
339 netsnmp_tdata_row *table_row;
340 struct alarmTable_entry *table_entry;
341 int ret;
342 netsnmp_session *sess = NULL;
343 char *secName;
344
345 DEBUGMSGTL(( "rmon:alarmTable", "alarmTable_handler called.\n"));
346 switch (reqinfo->mode) {
347 /*
348 * Read-support (also covers GetNext requests)
349 */
350 case MODE_GET:
351 for (request = requests; request; request = request->next) {
352 table_entry = (struct alarmTable_entry *)
353 netsnmp_tdata_extract_entry(request);
354 table_info = netsnmp_extract_table_info(request);
355
356 switch (table_info->colnum) {
357 case COLUMN_ALARMINDEX:
358 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
359 table_entry->alarmIndex);
360 break;
361 case COLUMN_ALARMINTERVAL:
362 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
363 table_entry->alarmInterval);
364 break;
365 case COLUMN_ALARMVARIABLE:
366 snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID,
367 (u_char *) table_entry->
368 alarmVariable,
369 table_entry->alarmVariable_len *
370 sizeof(oid));
371 break;
372 case COLUMN_ALARMSAMPLETYPE:
373 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
374 table_entry->alarmSampleType);
375 break;
376 case COLUMN_ALARMVALUE:
377 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
378 table_entry->alarmValue);
379 break;
380 case COLUMN_ALARMSTARTUPALARM:
381 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
382 table_entry->alarmStartupAlarm);
383 break;
384 case COLUMN_ALARMRISINGTHRESHOLD:
385 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
386 table_entry->
387 alarmRisingThreshold);
388 break;
389 case COLUMN_ALARMFALLINGTHRESHOLD:
390 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
391 table_entry->
392 alarmFallingThreshold);
393 break;
394 case COLUMN_ALARMRISINGEVENTINDEX:
395 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
396 table_entry->
397 alarmRisingEventIndex);
398 break;
399 case COLUMN_ALARMFALLINGEVENTINDEX:
400 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
401 table_entry->
402 alarmFallingEventIndex);
403 break;
404 case COLUMN_ALARMOWNER:
405 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
406 (u_char *) table_entry->
407 alarmOwner,
408 table_entry->alarmOwner_len);
409 break;
410 case COLUMN_ALARMSTATUS:
411 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
412 table_entry->alarmStatus);
413 break;
414 }
415 }
416 break;
417
418 /*
419 * Write-support
420 */
421 case MODE_SET_RESERVE1:
422 for (request = requests; request; request = request->next) {
423 table_entry = (struct alarmTable_entry *)
424 netsnmp_tdata_extract_entry(request);
425 table_info = netsnmp_extract_table_info(request);
426
427 switch (table_info->colnum) {
428 case COLUMN_ALARMINTERVAL:
429 /*
430 * or possibly 'netsnmp_check_vb_int_range'
431 */
432 ret = netsnmp_check_vb_int(request->requestvb);
433 if (ret != SNMP_ERR_NOERROR) {
434 netsnmp_set_request_error(reqinfo, request, ret);
435 return SNMP_ERR_NOERROR;
436 }
437 break;
438 case COLUMN_ALARMVARIABLE:
439 /*
440 * or possibly 'netsnmp_check_vb_type_and_max_size'
441 */
442 break;
443 case COLUMN_ALARMSAMPLETYPE:
444 /*
445 * or possibly 'netsnmp_check_vb_int_range'
446 */
447 ret = netsnmp_check_vb_int(request->requestvb);
448 if (ret != SNMP_ERR_NOERROR) {
449 netsnmp_set_request_error(reqinfo, request, ret);
450 return SNMP_ERR_NOERROR;
451 }
452 break;
453 case COLUMN_ALARMSTARTUPALARM:
454 /*
455 * or possibly 'netsnmp_check_vb_int_range'
456 */
457 ret = netsnmp_check_vb_int(request->requestvb);
458 if (ret != SNMP_ERR_NOERROR) {
459 netsnmp_set_request_error(reqinfo, request, ret);
460 return SNMP_ERR_NOERROR;
461 }
462 break;
463 case COLUMN_ALARMRISINGTHRESHOLD:
464 /*
465 * or possibly 'netsnmp_check_vb_int_range'
466 */
467 ret = netsnmp_check_vb_int(request->requestvb);
468 if (ret != SNMP_ERR_NOERROR) {
469 netsnmp_set_request_error(reqinfo, request, ret);
470 return SNMP_ERR_NOERROR;
471 }
472 break;
473 case COLUMN_ALARMFALLINGTHRESHOLD:
474 /*
475 * or possibly 'netsnmp_check_vb_int_range'
476 */
477 ret = netsnmp_check_vb_int(request->requestvb);
478 if (ret != SNMP_ERR_NOERROR) {
479 netsnmp_set_request_error(reqinfo, request, ret);
480 return SNMP_ERR_NOERROR;
481 }
482 break;
483 case COLUMN_ALARMRISINGEVENTINDEX:
484 /*
485 * or possibly 'netsnmp_check_vb_int_range'
486 */
487 ret = netsnmp_check_vb_int(request->requestvb);
488 if (ret != SNMP_ERR_NOERROR) {
489 netsnmp_set_request_error(reqinfo, request, ret);
490 return SNMP_ERR_NOERROR;
491 }
492 break;
493 case COLUMN_ALARMFALLINGEVENTINDEX:
494 /*
495 * or possibly 'netsnmp_check_vb_int_range'
496 */
497 ret = netsnmp_check_vb_int(request->requestvb);
498 if (ret != SNMP_ERR_NOERROR) {
499 netsnmp_set_request_error(reqinfo, request, ret);
500 return SNMP_ERR_NOERROR;
501 }
502 break;
503 case COLUMN_ALARMOWNER:
504 /*
505 * or possibly 'netsnmp_check_vb_type_and_max_size'
506 */
507 break;
508 case COLUMN_ALARMSTATUS:
509 /*
510 * or possibly 'netsnmp_check_vb_int_range'
511 */
512 ret = netsnmp_check_vb_int(request->requestvb);
513 if (ret != SNMP_ERR_NOERROR) {
514 netsnmp_set_request_error(reqinfo, request, ret);
515 return SNMP_ERR_NOERROR;
516 }
517 break;
518 default:
519 netsnmp_set_request_error(reqinfo, request,
520 SNMP_ERR_NOTWRITABLE);
521 return SNMP_ERR_NOERROR;
522 }
523 }
524 break;
525
526 case MODE_SET_RESERVE2:
527 for (request = requests; request; request = request->next) {
528 table_row = netsnmp_tdata_extract_row(request);
529 table_data = netsnmp_tdata_extract_table(request);
530 table_info = netsnmp_extract_table_info(request);
531
532 switch (table_info->colnum) {
533 case COLUMN_ALARMINTERVAL:
534 case COLUMN_ALARMVARIABLE:
535 case COLUMN_ALARMSAMPLETYPE:
536 case COLUMN_ALARMSTARTUPALARM:
537 case COLUMN_ALARMRISINGTHRESHOLD:
538 case COLUMN_ALARMFALLINGTHRESHOLD:
539 case COLUMN_ALARMRISINGEVENTINDEX:
540 case COLUMN_ALARMFALLINGEVENTINDEX:
541 case COLUMN_ALARMOWNER:
542 case COLUMN_ALARMSTATUS:
543 if (!table_row) {
544 table_row =
545 alarmTable_createEntry(table_data,
546 *table_info->indexes->val.
547 integer);
548 if (table_row) {
549 netsnmp_insert_tdata_row(request, table_row);
550 } else {
551 netsnmp_set_request_error(reqinfo, request,
552 SNMP_ERR_RESOURCEUNAVAILABLE);
553 return SNMP_ERR_NOERROR;
554 }
555 }
556 break;
557 }
558 }
559 break;
560
561 case MODE_SET_FREE:
562 for (request = requests; request; request = request->next) {
563 table_entry = (struct alarmTable_entry *)
564 netsnmp_tdata_extract_entry(request);
565 table_row = netsnmp_tdata_extract_row(request);
566 table_data = netsnmp_tdata_extract_table(request);
567 table_info = netsnmp_extract_table_info(request);
568
569 switch (table_info->colnum) {
570 case COLUMN_ALARMINTERVAL:
571 case COLUMN_ALARMVARIABLE:
572 case COLUMN_ALARMSAMPLETYPE:
573 case COLUMN_ALARMSTARTUPALARM:
574 case COLUMN_ALARMRISINGTHRESHOLD:
575 case COLUMN_ALARMFALLINGTHRESHOLD:
576 case COLUMN_ALARMRISINGEVENTINDEX:
577 case COLUMN_ALARMFALLINGEVENTINDEX:
578 case COLUMN_ALARMOWNER:
579 case COLUMN_ALARMSTATUS:
580 if (table_entry && !table_entry->valid) {
581 alarmTable_removeEntry(table_data, table_row);
582 }
583 break;
584 }
585 }
586 break;
587
588 case MODE_SET_ACTION:
589 for (request = requests; request; request = request->next) {
590 table_entry = (struct alarmTable_entry *)
591 netsnmp_tdata_extract_entry(request);
592 table_info = netsnmp_extract_table_info(request);
593
594 switch (table_info->colnum) {
595 case COLUMN_ALARMINTERVAL:
596 table_entry->old_alarmInterval =
597 table_entry->alarmInterval;
598 table_entry->alarmInterval =
599 *request->requestvb->val.integer;
600 break;
601 case COLUMN_ALARMVARIABLE:
602 table_entry->alarmVariable_len =
603 request->requestvb->val_len / sizeof(oid);
604 memset(table_entry->alarmVariable, 0,
605 sizeof(table_entry->alarmVariable));
606 memcpy(table_entry->alarmVariable,
607 request->requestvb->val.objid,
608 request->requestvb->val_len);
609 break;
610 case COLUMN_ALARMSAMPLETYPE:
611 table_entry->old_alarmSampleType =
612 table_entry->alarmSampleType;
613 table_entry->alarmSampleType =
614 *request->requestvb->val.integer;
615 break;
616 case COLUMN_ALARMSTARTUPALARM:
617 table_entry->old_alarmStartupAlarm =
618 table_entry->alarmStartupAlarm;
619 table_entry->alarmStartupAlarm =
620 *request->requestvb->val.integer;
621 break;
622 case COLUMN_ALARMRISINGTHRESHOLD:
623 table_entry->old_alarmRisingThreshold =
624 table_entry->alarmRisingThreshold;
625 table_entry->alarmRisingThreshold =
626 *request->requestvb->val.integer;
627 break;
628 case COLUMN_ALARMFALLINGTHRESHOLD:
629 table_entry->old_alarmFallingThreshold =
630 table_entry->alarmFallingThreshold;
631 table_entry->alarmFallingThreshold =
632 *request->requestvb->val.integer;
633 break;
634 case COLUMN_ALARMRISINGEVENTINDEX:
635 table_entry->old_alarmRisingEventIndex =
636 table_entry->alarmRisingEventIndex;
637 table_entry->alarmRisingEventIndex =
638 *request->requestvb->val.integer;
639 break;
640 case COLUMN_ALARMFALLINGEVENTINDEX:
641 table_entry->old_alarmFallingEventIndex =
642 table_entry->alarmFallingEventIndex;
643 table_entry->alarmFallingEventIndex =
644 *request->requestvb->val.integer;
645 break;
646 case COLUMN_ALARMOWNER:
647 memcpy(table_entry->old_alarmOwner,
648 table_entry->alarmOwner,
649 sizeof(table_entry->alarmOwner));
650 table_entry->old_alarmOwner_len =
651 table_entry->alarmOwner_len;
652 memset(table_entry->alarmOwner, 0,
653 sizeof(table_entry->alarmOwner));
654 memcpy(table_entry->alarmOwner,
655 request->requestvb->val.string,
656 request->requestvb->val_len);
657 table_entry->alarmOwner_len = request->requestvb->val_len;
658 break;
659 case COLUMN_ALARMSTATUS:
660 table_entry->old_alarmStatus = table_entry->alarmStatus;
661 table_entry->alarmStatus =
662 *request->requestvb->val.integer;
663 break;
664 }
665 }
666 break;
667
668 case MODE_SET_UNDO:
669 for (request = requests; request; request = request->next) {
670 table_entry = (struct alarmTable_entry *)
671 netsnmp_tdata_extract_entry(request);
672 table_row = netsnmp_tdata_extract_row(request);
673 table_data = netsnmp_tdata_extract_table(request);
674 table_info = netsnmp_extract_table_info(request);
675
676 switch (table_info->colnum) {
677 case COLUMN_ALARMINTERVAL:
678 if (table_entry && !table_entry->valid) {
679 alarmTable_removeEntry(table_data, table_row);
680 } else {
681 table_entry->alarmInterval =
682 table_entry->old_alarmInterval;
683 table_entry->old_alarmInterval = 0;
684 }
685 break;
686 case COLUMN_ALARMVARIABLE:
687 if (table_entry && !table_entry->valid) {
688 alarmTable_removeEntry(table_data, table_row);
689 } else {
690 memcpy(table_entry->alarmVariable,
691 table_entry->old_alarmVariable,
692 sizeof(table_entry->alarmVariable));
693 memset(table_entry->old_alarmVariable, 0,
694 sizeof(table_entry->alarmVariable));
695 table_entry->alarmVariable_len =
696 table_entry->old_alarmVariable_len;
697 }
698 break;
699 case COLUMN_ALARMSAMPLETYPE:
700 if (table_entry && !table_entry->valid) {
701 alarmTable_removeEntry(table_data, table_row);
702 } else {
703 table_entry->alarmSampleType =
704 table_entry->old_alarmSampleType;
705 table_entry->old_alarmSampleType = 0;
706 }
707 break;
708 case COLUMN_ALARMSTARTUPALARM:
709 if (table_entry && !table_entry->valid) {
710 alarmTable_removeEntry(table_data, table_row);
711 } else {
712 table_entry->alarmStartupAlarm =
713 table_entry->old_alarmStartupAlarm;
714 table_entry->old_alarmStartupAlarm = 0;
715 }
716 break;
717 case COLUMN_ALARMRISINGTHRESHOLD:
718 if (table_entry && !table_entry->valid) {
719 alarmTable_removeEntry(table_data, table_row);
720 } else {
721 table_entry->alarmRisingThreshold =
722 table_entry->old_alarmRisingThreshold;
723 table_entry->old_alarmRisingThreshold = 0;
724 }
725 break;
726 case COLUMN_ALARMFALLINGTHRESHOLD:
727 if (table_entry && !table_entry->valid) {
728 alarmTable_removeEntry(table_data, table_row);
729 } else {
730 table_entry->alarmFallingThreshold =
731 table_entry->old_alarmFallingThreshold;
732 table_entry->old_alarmFallingThreshold = 0;
733 }
734 break;
735 case COLUMN_ALARMRISINGEVENTINDEX:
736 if (table_entry && !table_entry->valid) {
737 alarmTable_removeEntry(table_data, table_row);
738 } else {
739 table_entry->alarmRisingEventIndex =
740 table_entry->old_alarmRisingEventIndex;
741 table_entry->old_alarmRisingEventIndex = 0;
742 }
743 break;
744 case COLUMN_ALARMFALLINGEVENTINDEX:
745 if (table_entry && !table_entry->valid) {
746 alarmTable_removeEntry(table_data, table_row);
747 } else {
748 table_entry->alarmFallingEventIndex =
749 table_entry->old_alarmFallingEventIndex;
750 table_entry->old_alarmFallingEventIndex = 0;
751 }
752 break;
753 case COLUMN_ALARMOWNER:
754 if (table_entry && !table_entry->valid) {
755 alarmTable_removeEntry(table_data, table_row);
756 } else {
757 memcpy(table_entry->alarmOwner,
758 table_entry->old_alarmOwner,
759 sizeof(table_entry->alarmOwner));
760 memset(table_entry->old_alarmOwner, 0,
761 sizeof(table_entry->alarmOwner));
762 table_entry->alarmOwner_len =
763 table_entry->old_alarmOwner_len;
764 }
765 break;
766 case COLUMN_ALARMSTATUS:
767 if (table_entry && !table_entry->valid) {
768 alarmTable_removeEntry(table_data, table_row);
769 } else {
770 table_entry->alarmStatus =
771 table_entry->old_alarmStatus;
772 table_entry->old_alarmStatus = 0;
773 }
774 break;
775 }
776 }
777 break;
778
779 case MODE_SET_COMMIT:
780 for (request = requests; request; request = request->next) {
781 table_entry = (struct alarmTable_entry *)
782 netsnmp_tdata_extract_entry(request);
783 table_info = netsnmp_extract_table_info(request);
784
785 switch (table_info->colnum) {
786 case COLUMN_ALARMINTERVAL:
787 case COLUMN_ALARMVARIABLE:
788 case COLUMN_ALARMSAMPLETYPE:
789 case COLUMN_ALARMSTARTUPALARM:
790 case COLUMN_ALARMRISINGTHRESHOLD:
791 case COLUMN_ALARMFALLINGTHRESHOLD:
792 case COLUMN_ALARMRISINGEVENTINDEX:
793 case COLUMN_ALARMFALLINGEVENTINDEX:
794 case COLUMN_ALARMOWNER:
795 if (table_entry && !table_entry->valid) {
796 table_entry->valid = 1;
797 }
798 break;
799 case COLUMN_ALARMSTATUS:
800 switch (*request->requestvb->val.integer) {
801 case RMON1_ENTRY_VALID:
802 alarmTable_enable( table_entry );
803 break;
804 case RMON1_ENTRY_UNDER_CREATION:
805 alarmTable_disable( table_entry );
806 #if 0
807 table_entry->session = (netsnmp_session *)
808 netsnmp_iquery_pdu_session(reqinfo->asp->pdu);
809 #else
810 secName = netsnmp_ds_get_string(NETSNMP_DS_APPLICATION_ID,
811 NETSNMP_DS_AGENT_INTERNAL_SECNAME);
812 if (secName) {
813 sess = netsnmp_iquery_user_session(secName);
814 netsnmp_query_set_default_session(sess);
815 DEBUGMSGTL(("rmon:alarmTable", "user name %s\n", secName));
816 } else {
817 snmp_log(LOG_ERR, "user name not found\n");
818 config_perror("Unknown user name\n");
819 }
820
821 if (NULL == sess) {
822 sess = netsnmp_query_get_default_session();
823 if (NULL == sess) {
824 config_perror
825 ("You must specify a default user name using the agentSecName token\n");
826 return SNMP_ERR_NOERROR;
827 }
828 }
829 #endif
830 break;
831 case RMON1_ENTRY_INVALID:
832 table_row = netsnmp_tdata_extract_row(request);
833 table_data = netsnmp_tdata_extract_table(request);
834 alarmTable_removeEntry(table_data, table_row);
835 }
836 break;
837 }
838 }
839 break;
840 }
841 return SNMP_ERR_NOERROR;
842 }