Debian Codegraph @

agent/mibgroup/Rmon/alarm.c

raw
1 /**************************************************************
2 * Copyright (C) 2001 Alex Rozin, Optical Access
3 *
4 * All Rights Reserved
5 *
6 * Permission to use, copy, modify and distribute this software and its
7 * documentation for any purpose and without fee is hereby granted,
8 * provided that the above copyright notice appear in all copies and that
9 * both that copyright notice and this permission notice appear in
10 * supporting documentation.
11 *
12 * ALEX ROZIN DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
13 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
14 * ALEX ROZIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
15 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
16 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
17 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
18 * SOFTWARE.
19 ******************************************************************/
20
21 #include <net-snmp/net-snmp-config.h>
22
23 #ifdef HAVE_STDLIB_H
24 #include <stdlib.h>
25 #endif
26 #ifdef HAVE_UNISTD_H
27 #include <unistd.h>
28 #endif
29 #ifdef TIME_WITH_SYS_TIME
30 # include <sys/time.h>
31 # include <time.h>
32 #else
33 # ifdef HAVE_SYS_TIME_H
34 # include <sys/time.h>
35 # else
36 # include <time.h>
37 # endif
38 #endif
39
40 #include <net-snmp/net-snmp-includes.h>
41 #include <net-snmp/agent/net-snmp-agent-includes.h>
42 #include "alarm.h"
43 #include "event.h"
44 /*
45 * Implementation headers
46 */
47 #include "agutil_api.h"
48 #include "row_api.h"
49 /*
50 * File scope definitions section
51 */
52 /*
53 * from MIB compilation
54 */
55 #define alarmEntryFirstIndexBegin 11
56 #define MMM_MAX 0xFFFFFFFFl
57 #define IDalarmIndex 1
58 #define IDalarmInterval 2
59 #define IDalarmVariable 3
60 #define IDalarmSampleType 4
61 #define IDalarmValue 5
62 #define IDalarmStartupAlarm 6
63 #define IDalarmRisingThreshold 7
64 #define IDalarmFallingThreshold 8
65 #define IDalarmRisingEventIndex 9
66 #define IDalarmFallingEventIndex 10
67 #define IDalarmOwner 11
68 #define IDalarmStatus 12
69 #define MIN_alarmEventIndex 0
70 #define MAX_alarmEventIndex 65535
71 typedef enum {
72 SAMPLE_TYPE_ABSOLUTE =
73 1,
74 SAMPLE_TYPE_DELTE
75 } SAMPLE_TYPE_T;
76
77 typedef enum {
78 ALARM_NOTHING =
79 0,
80 ALARM_RISING,
81 ALARM_FALLING,
82 ALARM_BOTH
83 } ALARM_TYPE_T;
84
85 typedef struct {
86 u_long
87 interval;
88 u_long
89 timer_id;
90 VAR_OID_T
91 var_name;
92 SAMPLE_TYPE_T
93 sample_type;
94 ALARM_TYPE_T
95 startup_type; /* RISING | FALLING | BOTH */
96
97 u_long
98 rising_threshold;
99 u_long
100 falling_threshold;
101 u_long
102 rising_event_index;
103 u_long
104 falling_event_index;
105
106 u_long
107 last_abs_value;
108 u_long
109 value;
110 ALARM_TYPE_T
111 prev_alarm; /* NOTHING | RISING | FALLING */
112 } CRTL_ENTRY_T;
113
114 /*
115 * Main section
116 */
117
118 static TABLE_DEFINTION_T
119 AlarmCtrlTable;
120 static TABLE_DEFINTION_T *
121 table_ptr = &
122 AlarmCtrlTable;
123
124 #if 0 /* KUKU */
125 static u_long
126 kuku_sum =
127 0,
128 kuku_cnt =
129 0;
130 #endif
131
132 static unsigned char zero_octet_string[1];
133
134 static int
135 fetch_var_val(oid * name, size_t namelen, u_long * new_value)
136 {
137 netsnmp_subtree *tree_ptr;
138 size_t var_len;
139 WriteMethod *write_method;
140 struct variable called_var;
141 register struct variable *s_var_ptr = NULL;
142 register u_char *access;
143
144
145 tree_ptr = netsnmp_subtree_find(name, namelen, NULL, "");
146 if (!tree_ptr) {
147 ag_trace("tree_ptr is NULL");
148 return SNMP_ERR_NOSUCHNAME;
149 }
150
151
152 memcpy(called_var.name, tree_ptr->name_a,
153 tree_ptr->namelen * sizeof(oid));
154
155 if (tree_ptr->reginfo &&
156 tree_ptr->reginfo->handler &&
157 tree_ptr->reginfo->handler->next &&
158 tree_ptr->reginfo->handler->next->myvoid) {
159 s_var_ptr = (struct variable *)tree_ptr->reginfo->handler->next->myvoid;
160 }
161
162 if (s_var_ptr) {
163 if (s_var_ptr->namelen) {
164 called_var.namelen =
165 tree_ptr->namelen;
166 called_var.type = s_var_ptr->type;
167 called_var.magic = s_var_ptr->magic;
168 called_var.acl = s_var_ptr->acl;
169 called_var.findVar = s_var_ptr->findVar;
170 access =
171 (*(s_var_ptr->findVar)) (&called_var, name, &namelen,
172 1, &var_len, &write_method);
173
174 if (access
175 && snmp_oid_compare(name, namelen, tree_ptr->end_a,
176 tree_ptr->end_len) > 0) {
177 memcpy(name, tree_ptr->end_a, tree_ptr->end_len);
178 access = NULL;
179 ag_trace("access := 0");
180 }
181
182 if (access) {
183
184 /*
185 * check 'var_len' ?
186 */
187
188 /*
189 * check type
190 */
191 switch (called_var.type) {
192 case ASN_INTEGER:
193 case ASN_COUNTER:
194 case ASN_TIMETICKS:
195 case ASN_GAUGE:
196 case ASN_COUNTER64:
197 break;
198 default:
199 ag_trace("invalid type: %d",
200 (int) called_var.type);
201 return SNMP_ERR_GENERR;
202 }
203 *new_value = *(u_long *) access;
204 return SNMP_ERR_NOERROR;
205 }
206 }
207 }
208
209 return SNMP_ERR_NOSUCHNAME;
210 }
211
212 static void
213 alarm_check_var(unsigned int clientreg, void *clientarg)
214 {
215 RMON_ENTRY_T *hdr_ptr;
216 CRTL_ENTRY_T *body;
217 u_long new_value;
218 int ierr;
219
220 hdr_ptr = (RMON_ENTRY_T *) clientarg;
221 if (!hdr_ptr) {
222 ag_trace
223 ("Err: history_get_backet: hdr_ptr=NULL ? (Inserted in shock)");
224 return;
225 }
226
227 body = (CRTL_ENTRY_T *) hdr_ptr->body;
228 if (!body) {
229 ag_trace
230 ("Err: history_get_backet: body=NULL ? (Inserted in shock)");
231 return;
232 }
233
234 if (RMON1_ENTRY_VALID != hdr_ptr->status) {
235 ag_trace("Err: history_get_backet when entry %d is not valid ?!!",
236 (int) hdr_ptr->ctrl_index);
237 snmp_alarm_unregister(body->timer_id);
238 return;
239 }
240
241 ierr = fetch_var_val(body->var_name.objid,
242 body->var_name.length, &new_value);
243 if (SNMP_ERR_NOERROR != ierr) {
244 ag_trace("Err: Can't fetch var_name");
245 return;
246 }
247
248 body->value = (SAMPLE_TYPE_ABSOLUTE == body->sample_type) ?
249 new_value : new_value - body->last_abs_value;
250 body->last_abs_value = new_value;
251 /*
252 * ag_trace ("fetched value=%ld check %ld", (long) new_value, (long) body->value);
253 */
254 #if 0 /* KUKU */
255 kuku_sum += body->value;
256 kuku_cnt++;
257 #endif
258
259 if (ALARM_RISING != body->prev_alarm &&
260 body->value >= body->rising_threshold &&
261 SNMP_ERR_NOERROR == event_api_send_alarm(1, hdr_ptr->ctrl_index,
262 body->rising_event_index,
263 body->var_name.objid,
264 body->var_name.length,
265 ALARM_RISING, body->value,
266 body->rising_threshold,
267 "Rising"))
268 body->prev_alarm = ALARM_RISING;
269 else if (ALARM_FALLING != body->prev_alarm &&
270 body->value <= body->falling_threshold &&
271 SNMP_ERR_NOERROR == event_api_send_alarm(0,
272 hdr_ptr->ctrl_index,
273 body->
274 falling_event_index,
275 body->var_name.objid,
276 body->var_name.
277 length, ALARM_RISING,
278 body->value,
279 body->
280 falling_threshold,
281 "Falling"))
282 body->prev_alarm = ALARM_FALLING;
283 }
284
285 /*
286 * Control Table RowApi Callbacks
287 */
288
289 int
290 alarm_Create(RMON_ENTRY_T * eptr)
291 { /* create the body: alloc it and set defaults */
292 CRTL_ENTRY_T *body;
293 static VAR_OID_T DEFAULT_VAR = { 12, /* etherStatsPkts.1 */
294 {1, 3, 6, 1, 2, 1, 16, 1, 1, 1, 5, 1}
295 };
296
297
298 eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
299 if (!eptr->body)
300 return -3;
301 body = (CRTL_ENTRY_T *) eptr->body;
302
303 /*
304 * set defaults
305 */
306 body->interval = 1;
307 memcpy(&body->var_name, &DEFAULT_VAR, sizeof(VAR_OID_T));
308 body->sample_type = SAMPLE_TYPE_ABSOLUTE;
309 body->startup_type = ALARM_BOTH;
310 body->rising_threshold = MMM_MAX;
311 body->falling_threshold = 0;
312 body->rising_event_index = body->falling_event_index = 0;
313
314 body->prev_alarm = ALARM_NOTHING;
315
316 return 0;
317 }
318
319 int
320 alarm_Validate(RMON_ENTRY_T * eptr)
321 {
322 CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
323
324 if (body->rising_threshold <= body->falling_threshold) {
325 ag_trace("alarm_Validate failed: %lu must be > %lu",
326 body->rising_threshold, body->falling_threshold);
327 return SNMP_ERR_BADVALUE;
328 }
329
330 return 0;
331 }
332
333 int
334 alarm_Activate(RMON_ENTRY_T * eptr)
335 {
336 CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
337 int ierr;
338
339 #if 0 /* KUKU */
340 kuku_sum = 0;
341 kuku_cnt = 0;
342 #endif
343 ierr = fetch_var_val(body->var_name.objid,
344 body->var_name.length, &body->last_abs_value);
345 if (SNMP_ERR_NOERROR != ierr) {
346 ag_trace("Can't fetch var_name");
347 return ierr;
348 }
349
350 if (SAMPLE_TYPE_ABSOLUTE != body->sample_type) {
351 /*
352 * check startup alarm
353 */
354 if (ALARM_RISING == body->startup_type ||
355 ALARM_BOTH == body->startup_type) {
356 if (body->last_abs_value >= body->rising_threshold) {
357 event_api_send_alarm(1, eptr->ctrl_index,
358 body->rising_event_index,
359 body->var_name.objid,
360 body->var_name.length,
361 ALARM_RISING, body->value,
362 body->rising_threshold,
363 "Startup Rising");
364 }
365 }
366
367 if (ALARM_FALLING == body->startup_type ||
368 ALARM_BOTH == body->startup_type) {
369 if (body->last_abs_value <= body->falling_threshold) {
370 event_api_send_alarm(0, eptr->ctrl_index,
371 body->falling_event_index,
372 body->var_name.objid,
373 body->var_name.length,
374 ALARM_RISING, body->value,
375 body->falling_threshold,
376 "Startup Falling");
377 }
378 }
379
380 }
381
382 body->timer_id = snmp_alarm_register(body->interval, SA_REPEAT,
383 alarm_check_var, eptr);
384 return 0;
385 }
386
387 int
388 alarm_Deactivate(RMON_ENTRY_T * eptr)
389 {
390 CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
391
392 snmp_alarm_unregister(body->timer_id);
393 #if 0 /* KUKU */
394 ag_trace("kuku_sum=%ld kuku_cnt=%ld sp=%ld",
395 (long) kuku_sum, (long) kuku_cnt,
396 (long) (kuku_sum / kuku_cnt));
397 #endif
398 return 0;
399 }
400
401 int
402 alarm_Copy(RMON_ENTRY_T * eptr)
403 {
404 CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
405 CRTL_ENTRY_T *clone = (CRTL_ENTRY_T *) eptr->tmp;
406
407 if (RMON1_ENTRY_VALID == eptr->status &&
408 clone->rising_threshold <= clone->falling_threshold) {
409 ag_trace("alarm_Copy failed: invalid thresholds");
410 return SNMP_ERR_BADVALUE;
411 }
412
413 if (clone->interval != body->interval) {
414 if (RMON1_ENTRY_VALID == eptr->status) {
415 snmp_alarm_unregister(body->timer_id);
416 body->timer_id =
417 snmp_alarm_register(clone->interval, SA_REPEAT,
418 alarm_check_var, eptr);
419 }
420 body->interval = clone->interval;
421 }
422
423 if (snmp_oid_compare(clone->var_name.objid, clone->var_name.length,
424 body->var_name.objid, body->var_name.length)) {
425 memcpy(&body->var_name, &clone->var_name, sizeof(VAR_OID_T));
426 }
427
428 body->sample_type = clone->sample_type;
429 body->startup_type = clone->startup_type;
430 body->sample_type = clone->sample_type;
431 body->rising_threshold = clone->rising_threshold;
432 body->falling_threshold = clone->falling_threshold;
433 body->rising_event_index = clone->rising_event_index;
434 body->falling_event_index = clone->falling_event_index;
435 /*
436 * ag_trace ("alarm_Copy: rising_threshold=%lu falling_threshold=%lu",
437 * body->rising_threshold, body->falling_threshold);
438 */
439 return 0;
440 }
441
442 static int
443 write_alarmEntry(int action, u_char * var_val, u_char var_val_type,
444 size_t var_val_len, u_char * statP,
445 oid * name, size_t name_len)
446 {
447 long long_tmp;
448 int leaf_id, snmp_status;
449 static int prev_action = COMMIT;
450 RMON_ENTRY_T *hdr;
451 CRTL_ENTRY_T *cloned_body;
452 CRTL_ENTRY_T *body;
453
454 switch (action) {
455 case RESERVE1:
456 case FREE:
457 case UNDO:
458 case ACTION:
459 case COMMIT:
460 default:
461 return ROWAPI_do_another_action(name, alarmEntryFirstIndexBegin,
462 action, &prev_action,
463 table_ptr, sizeof(CRTL_ENTRY_T));
464 case RESERVE2:
465 /*
466 * get values from PDU, check them and save them in the cloned entry
467 */
468 long_tmp = name[alarmEntryFirstIndexBegin];
469 leaf_id = (int) name[alarmEntryFirstIndexBegin - 1];
470 hdr = ROWAPI_find(table_ptr, long_tmp); /* it MUST be OK */
471 cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
472 body = (CRTL_ENTRY_T *) hdr->body;
473 switch (leaf_id) {
474 case IDalarmInterval:
475 snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
476 var_val_len,
477 0, MMM_MAX, &long_tmp);
478 if (SNMP_ERR_NOERROR != snmp_status) {
479 return snmp_status;
480 }
481 cloned_body->interval = long_tmp;
482 break;
483 case IDalarmVariable:
484 snmp_status = AGUTIL_get_oid_value(var_val, var_val_type,
485 var_val_len,
486 &cloned_body->var_name);
487 if (SNMP_ERR_NOERROR != snmp_status) {
488 return snmp_status;
489 }
490 if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
491 snmp_oid_compare(cloned_body->var_name.objid,
492 cloned_body->var_name.length,
493 body->var_name.objid,
494 body->var_name.length))
495 return SNMP_ERR_BADVALUE;
496 break;
497
498 break;
499 case IDalarmSampleType:
500 snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
501 var_val_len,
502 SAMPLE_TYPE_ABSOLUTE,
503 SAMPLE_TYPE_DELTE,
504 &long_tmp);
505 if (SNMP_ERR_NOERROR != snmp_status) {
506 return snmp_status;
507 }
508 cloned_body->sample_type = long_tmp;
509 break;
510 case IDalarmStartupAlarm:
511 snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
512 var_val_len,
513 ALARM_RISING,
514 ALARM_BOTH, &long_tmp);
515 if (SNMP_ERR_NOERROR != snmp_status) {
516 return snmp_status;
517 }
518 cloned_body->startup_type = long_tmp;
519 break;
520 case IDalarmRisingThreshold:
521 snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
522 var_val_len,
523 0, MMM_MAX, &long_tmp);
524 if (SNMP_ERR_NOERROR != snmp_status) {
525 return snmp_status;
526 }
527 cloned_body->rising_threshold = long_tmp;
528 break;
529 case IDalarmFallingThreshold:
530 snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
531 var_val_len,
532 0, 0xFFFFFFFFl, &long_tmp);
533 if (SNMP_ERR_NOERROR != snmp_status) {
534 return snmp_status;
535 }
536 cloned_body->falling_threshold = long_tmp;
537 break;
538 case IDalarmRisingEventIndex:
539 snmp_status = AGUTIL_get_int_value(var_val, var_val_type, var_val_len, 0, /* min. value */
540 0, /* max. value */
541 &long_tmp);
542 if (SNMP_ERR_NOERROR != snmp_status) {
543 return snmp_status;
544 }
545 cloned_body->rising_event_index = long_tmp;
546 break;
547 case IDalarmFallingEventIndex:
548 snmp_status = AGUTIL_get_int_value(var_val, var_val_type, var_val_len, 0, /* min. value */
549 0, /* max. value */
550 &long_tmp);
551 if (SNMP_ERR_NOERROR != snmp_status) {
552 return snmp_status;
553 }
554 cloned_body->falling_event_index = long_tmp;
555 break;
556 case IDalarmOwner:
557 if (hdr->new_owner)
558 AGFREE(hdr->new_owner);
559 hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);
560 if (!hdr->new_owner)
561 return SNMP_ERR_TOOBIG;
562 snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
563 var_val_len,
564 MAX_OWNERSTRING,
565 1, NULL, hdr->new_owner);
566 if (SNMP_ERR_NOERROR != snmp_status) {
567 return snmp_status;
568 }
569
570 break;
571 case IDalarmStatus:
572 snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
573 var_val_len,
574 RMON1_ENTRY_VALID,
575 RMON1_ENTRY_INVALID,
576 &long_tmp);
577 if (SNMP_ERR_NOERROR != snmp_status) {
578 return snmp_status;
579 }
580 hdr->new_status = long_tmp;
581 break;
582 default:
583 ag_trace("%s:unknown leaf_id=%d\n", table_ptr->name,
584 (int) leaf_id);
585 return SNMP_ERR_NOSUCHNAME;
586 } /* of switch by 'leaf_id' */
587
588 break;
589 } /* of switch by actions */
590
591 prev_action = action;
592 return SNMP_ERR_NOERROR;
593 }
594
595 u_char *
596 var_alarmEntry(struct variable * vp, oid * name, size_t * length,
597 int exact, size_t * var_len, WriteMethod ** write_method)
598 {
599 static long long_return;
600 static CRTL_ENTRY_T theEntry;
601 RMON_ENTRY_T *hdr;
602
603 *write_method = write_alarmEntry;
604 hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
605 table_ptr,
606 &theEntry, sizeof(CRTL_ENTRY_T));
607 if (!hdr)
608 return NULL;
609
610 *var_len = sizeof(long); /* default */
611
612 switch (vp->magic) {
613 case IDalarmIndex:
614 long_return = hdr->ctrl_index;
615 return (u_char *) & long_return;
616 case IDalarmInterval:
617 long_return = theEntry.interval;
618 return (u_char *) & long_return;
619 case IDalarmVariable:
620 *var_len = sizeof(oid) * theEntry.var_name.length;
621 return (unsigned char *) theEntry.var_name.objid;
622 return (u_char *) & long_return;
623 case IDalarmSampleType:
624 long_return = theEntry.sample_type;
625 return (u_char *) & long_return;
626 case IDalarmValue:
627 long_return = theEntry.value;
628 return (u_char *) & long_return;
629 case IDalarmStartupAlarm:
630 long_return = theEntry.startup_type;
631 return (u_char *) & long_return;
632 case IDalarmRisingThreshold:
633 long_return = theEntry.rising_threshold;
634 return (u_char *) & long_return;
635 case IDalarmFallingThreshold:
636 long_return = theEntry.falling_threshold;
637 return (u_char *) & long_return;
638 case IDalarmRisingEventIndex:
639 long_return = theEntry.rising_event_index;
640 return (u_char *) & long_return;
641 case IDalarmFallingEventIndex:
642 long_return = theEntry.falling_event_index;
643 return (u_char *) & long_return;
644 case IDalarmOwner:
645 if (hdr->owner) {
646 *var_len = strlen(hdr->owner);
647 return (unsigned char *) hdr->owner;
648 } else {
649 *var_len = 0;
650 return zero_octet_string;
651 }
652
653 case IDalarmStatus:
654 long_return = hdr->status;
655 return (u_char *) & long_return;
656 default:
657 ag_trace("%s: unknown vp->magic=%d", table_ptr->name,
658 (int) vp->magic);
659 ERROR_MSG("");
660 }; /* of switch by 'vp->magic' */
661
662 return NULL;
663 }
664
665 /*
666 * Registration & Initialization section
667 */
668
669 oid oidalarmVariablesOid[] = { 1, 3, 6, 1, 2, 1, 16, 3 };
670
671 struct variable7 oidalarmVariables[] = {
672 {IDalarmIndex, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
673 var_alarmEntry, 3, {1, 1, 1}},
674 {IDalarmInterval, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
675 var_alarmEntry, 3, {1, 1, 2}},
676 {IDalarmVariable, ASN_OBJECT_ID, NETSNMP_OLDAPI_RWRITE,
677 var_alarmEntry, 3, {1, 1, 3}},
678 {IDalarmSampleType, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
679 var_alarmEntry, 3, {1, 1, 4}},
680 {IDalarmValue, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
681 var_alarmEntry, 3, {1, 1, 5}},
682 {IDalarmStartupAlarm, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
683 var_alarmEntry, 3, {1, 1, 6}},
684 {IDalarmRisingThreshold, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
685 var_alarmEntry, 3, {1, 1, 7}},
686 {IDalarmFallingThreshold, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
687 var_alarmEntry, 3, {1, 1, 8}},
688 {IDalarmRisingEventIndex, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
689 var_alarmEntry, 3, {1, 1, 9}},
690 {IDalarmFallingEventIndex, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
691 var_alarmEntry, 3, {1, 1, 10}},
692 {IDalarmOwner, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
693 var_alarmEntry, 3, {1, 1, 11}},
694 {IDalarmStatus, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
695 var_alarmEntry, 3, {1, 1, 12}}
696 };
697
698 void
699 init_alarm(void)
700 {
701 REGISTER_MIB("alarmTable", oidalarmVariables, variable7,
702 oidalarmVariablesOid);
703
704 ROWAPI_init_table(&AlarmCtrlTable, "Alarm", 0, &alarm_Create, NULL, /* &alarm_Clone, */
705 NULL, /* &alarm_Delete, */
706 &alarm_Validate,
707 &alarm_Activate, &alarm_Deactivate, &alarm_Copy);
708 }
709
710 /*
711 * end of file alarm.c
712 */