Debian Codegraph @

agent/mibgroup/mibII/ipCidrRouteTable.c

raw
1 /*
2 * Note: this file originally auto-generated by mib2c using
3 * : mib2c.iterate_access.conf$
4 */
5
6 #include <net-snmp/net-snmp-config.h>
7 #include <net-snmp/net-snmp-features.h>
8 #include "route_headers.h"
9 #include <net-snmp/net-snmp-includes.h>
10 #include <net-snmp/agent/net-snmp-agent-includes.h>
11 #include "ipCidrRouteTable.h"
12 #include "ipCidrRouteTable_checkfns.h"
13 #include "ipCidrRouteTable_access.h"
14
15 #include "var_route.h"
16
17 netsnmp_feature_require(oid_stash);
18 netsnmp_feature_require(get_routes);
19 netsnmp_feature_require(oid_stash_get_data);
20 netsnmp_feature_require(oid_stash_add_data);
21
22 static netsnmp_oid_stash_node *undoStorage;
23
24 struct undoInfo {
25 void *ptr;
26 size_t len;
27 };
28
29 void
30 free_undoInfo(void *vp)
31 {
32 struct undoInfo *ui = (struct undoInfo *) vp;
33 if (!ui)
34 return;
35 SNMP_FREE(ui->ptr);
36 SNMP_FREE(ui);
37 }
38
39 /** Initialize the ipCidrRouteTable table by defining its contents and how it's structured */
40 void
41 initialize_table_ipCidrRouteTable(void)
42 {
43 static oid ipCidrRouteTable_oid[] =
44 { 1, 3, 6, 1, 2, 1, 4, 24, 4 };
45 netsnmp_table_registration_info *table_info;
46 netsnmp_handler_registration *my_handler;
47 netsnmp_iterator_info *iinfo;
48
49 /** create the table registration information structures */
50 table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
51 iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
52
53 /** if your table is read only, it's easiest to change the
54 HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */
55 my_handler = netsnmp_create_handler_registration("ipCidrRouteTable",
56 ipCidrRouteTable_handler,
57 ipCidrRouteTable_oid,
58 OID_LENGTH
59 (ipCidrRouteTable_oid),
60 HANDLER_CAN_RWRITE);
61
62 if (!my_handler || !table_info || !iinfo) {
63 snmp_log(LOG_ERR,
64 "malloc failed in initialize_table_ipCidrRouteTable");
65 return; /** Serious error. */
66 }
67
68 /***************************************************
69 * Setting up the table's definition
70 */
71 netsnmp_table_helper_add_indexes(table_info, ASN_IPADDRESS,
72 /** index: ipCidrRouteDest */
73 ASN_IPADDRESS,
74 /** index: ipCidrRouteMask */
75 ASN_INTEGER,
76 /** index: ipCidrRouteTos */
77 ASN_IPADDRESS,
78 /** index: ipCidrRouteNextHop */
79 0);
80
81 /** Define the minimum and maximum accessible columns. This
82 optimizes retrieval. */
83 table_info->min_column = 1;
84 table_info->max_column = 16;
85
86 /** iterator access routines */
87 iinfo->get_first_data_point = ipCidrRouteTable_get_first_data_point;
88 iinfo->get_next_data_point = ipCidrRouteTable_get_next_data_point;
89
90 /** you may wish to set these as well */
91 #ifdef MAYBE_USE_THESE
92 iinfo->make_data_context = ipCidrRouteTable_context_convert_function;
93 iinfo->free_data_context = ipCidrRouteTable_data_free;
94
95 /** pick *only* one of these if you use them */
96 iinfo->free_loop_context = ipCidrRouteTable_loop_free;
97 iinfo->free_loop_context_at_end = ipCidrRouteTable_loop_free;
98 #endif
99
100 /** tie the two structures together */
101 iinfo->table_reginfo = table_info;
102
103 /***************************************************
104 * registering the table with the master agent
105 */
106 DEBUGMSGTL(("initialize_table_ipCidrRouteTable",
107 "Registering table ipCidrRouteTable as a table iterator\n"));
108 netsnmp_register_table_iterator2(my_handler, iinfo);
109 }
110
111 /** Initializes the ipCidrRouteTable module */
112 void
113 init_ipCidrRouteTable(void)
114 {
115
116 /** here we initialize all the tables we're planning on supporting */
117 initialize_table_ipCidrRouteTable();
118 }
119
120
121 /* globals */
122 static size_t rtsize;
123 static RTENTRY **rthead;
124
125 netsnmp_variable_list *
126 ipCidrRouteTable_set_indexes(RTENTRY *ourroute,
127 netsnmp_variable_list *put_index_data) {
128 netsnmp_variable_list *vptr;
129
130 /** ipCidrRouteDest */
131 vptr = put_index_data;
132 snmp_set_var_value(vptr, (u_char *) &((struct sockaddr_in *) (&ourroute->rt_dst))->sin_addr.s_addr,
133 sizeof(((struct sockaddr_in *) (&ourroute->rt_dst))->sin_addr));
134
135 /** ipCidrRouteMask */
136 vptr = vptr->next_variable;
137 snmp_set_var_value(vptr, (u_char *) &((struct sockaddr_in *) (&ourroute->rt_genmask))->sin_addr.s_addr,
138 sizeof(((struct sockaddr_in *) (&ourroute->rt_genmask))->sin_addr));
139
140 /** ipCidrRouteTos */
141 vptr = vptr->next_variable;
142 snmp_set_var_value(vptr, (u_char *) &ourroute->rt_tos,
143 sizeof(ourroute->rt_tos));
144 vptr = vptr->next_variable;
145
146 /** ipCidrRouteNextHop */
147 snmp_set_var_value(vptr,
148 (u_char *) &((struct sockaddr_in *) (&ourroute->rt_gateway))->sin_addr.s_addr,
149 sizeof(((struct sockaddr_in *) (&ourroute->rt_gateway))->sin_addr));
150
151 return put_index_data;
152 }
153
154 /** returns the first data point within the ipCidrRouteTable table data.
155
156 Set the my_loop_context variable to the first data point structure
157 of your choice (from which you can find the next one). This could
158 be anything from the first node in a linked list, to an integer
159 pointer containing the beginning of an array variable.
160
161 Set the my_data_context variable to something to be returned to
162 you later that will provide you with the data to return in a given
163 row. This could be the same pointer as what my_loop_context is
164 set to, or something different.
165
166 The put_index_data variable contains a list of snmp variable
167 bindings, one for each index in your table. Set the values of
168 each appropriately according to the data matching the first row
169 and return the put_index_data variable at the end of the function.
170 */
171 netsnmp_variable_list *
172 ipCidrRouteTable_get_first_data_point(void **my_loop_context,
173 void **my_data_context,
174 netsnmp_variable_list *
175 put_index_data,
176 netsnmp_iterator_info *mydata)
177 {
178 int *position;
179
180 /* we could do this with a file-static variable, but for learning
181 purposes we'll use memory allocation to demonstrate simplistic
182 freeing of a loop_context */
183 position = malloc(sizeof(position));
184 if (!position)
185 return NULL;
186
187 /* read the routing table into the route array. This function is
188 defined in var_route.c, but is sorted incorrectly for this
189 table. By using a table_iterator we don't do any sorting
190 ourselves and the table_iterator handles it all for us, so we
191 don't resort with different criteria. */
192 rthead = netsnmp_get_routes(&rtsize);
193
194 if (!rthead) {
195 snmp_log(LOG_ERR,"ipCidrRouteTable: failed to get routes\n");
196 free(position);
197 return NULL;
198 }
199
200 /* We use the positinonal count as our loop context */
201 *position = 0;
202 *my_loop_context = position;
203
204 /* our data context is the individual array element, in this case
205 it's the first. */
206 *my_data_context = rthead[*position];
207
208 /* now, save the index data into the passed in (linked list) pointer */
209 return ipCidrRouteTable_set_indexes(rthead[*position], put_index_data);
210 }
211
212 /** functionally the same as ipCidrRouteTable_get_first_data_point, but
213 my_loop_context has already been set to a previous value and should
214 be updated to the next in the list. For example, if it was a
215 linked list, you might want to cast it and the return
216 my_loop_context->next. The my_data_context pointer should be set
217 to something you need later and the indexes in put_index_data
218 updated again. */
219
220 netsnmp_variable_list *
221 ipCidrRouteTable_get_next_data_point(void **my_loop_context,
222 void **my_data_context,
223 netsnmp_variable_list *
224 put_index_data,
225 netsnmp_iterator_info *mydata)
226 {
227
228 int *position = (int *) *my_loop_context;
229
230 /* make sure we were called correctly */
231 if (!position)
232 return NULL;
233
234 /* go to the next route in the list */
235 (*position)++;
236
237 /* Are we beyond the end? */
238 if (*position >= rtsize) {
239 /* End of routes. stop here by returning NULL */
240 SNMP_FREE(position);
241 *my_loop_context = NULL;
242 *my_data_context = NULL;
243 return NULL;
244 }
245
246 /* our data context is the individual array element, in this case
247 it's the first. */
248 *my_data_context = rthead[*position];
249
250 /* now, save the index data into the passed in (linked list) pointer */
251 return ipCidrRouteTable_set_indexes(rthead[*position], put_index_data);
252 }
253
254 /** handles requests for the ipCidrRouteTable table, if anything else
255 needs to be done */
256 int
257 ipCidrRouteTable_handler(netsnmp_mib_handler *handler,
258 netsnmp_handler_registration *reginfo,
259 netsnmp_agent_request_info *reqinfo,
260 netsnmp_request_info *requests)
261 {
262
263 netsnmp_request_info *request;
264 netsnmp_table_request_info *table_info;
265 netsnmp_variable_list *var;
266
267 void *data_context;
268
269 /** column and row index encoded portion */
270 const oid * const suffix =
271 requests->requestvb->name + reginfo->rootoid_len + 1;
272 const size_t suffix_len = requests->requestvb->name_length -
273 (reginfo->rootoid_len + 1);
274
275 for (request = requests; request; request = request->next) {
276 var = request->requestvb;
277 if (request->processed != 0)
278 continue;
279
280 data_context = netsnmp_extract_iterator_context(request);
281 if (data_context == NULL) {
282 if (reqinfo->mode == MODE_GET) {
283 netsnmp_set_request_error(reqinfo, request,
284 SNMP_NOSUCHINSTANCE);
285 continue;
286 }
287 /** XXX: no row existed, if you support creation and this is a
288 set, start dealing with it here, else continue */
289 }
290
291 /** extracts the information about the table from the request */
292 table_info = netsnmp_extract_table_info(request);
293 /** table_info->colnum contains the column number requested */
294 /** table_info->indexes contains a linked list of snmp variable
295 bindings for the indexes of the table. Values in the list
296 have been set corresponding to the indexes of the
297 request */
298 if (table_info == NULL) {
299 continue;
300 }
301
302 switch (reqinfo->mode) {
303 case MODE_GET:
304 switch (table_info->colnum) {
305 case COLUMN_IPCIDRROUTEDEST:
306 {
307 u_long *retval;
308 size_t retval_len = 0;
309 retval =
310 get_ipCidrRouteDest(data_context, &retval_len);
311 snmp_set_var_typed_value(var, ASN_IPADDRESS,
312 (const u_char *) retval,
313 retval_len);
314 }
315 break;
316
317 case COLUMN_IPCIDRROUTEMASK:
318 {
319 u_long *retval;
320 size_t retval_len = 0;
321 retval =
322 get_ipCidrRouteMask(data_context, &retval_len);
323 snmp_set_var_typed_value(var, ASN_IPADDRESS,
324 (const u_char *) retval,
325 retval_len);
326 }
327 break;
328
329 case COLUMN_IPCIDRROUTETOS:
330 {
331 long *retval;
332 size_t retval_len = 0;
333 retval = get_ipCidrRouteTos(data_context, &retval_len);
334 snmp_set_var_typed_value(var, ASN_INTEGER,
335 (const u_char *) retval,
336 retval_len);
337 }
338 break;
339
340 case COLUMN_IPCIDRROUTENEXTHOP:
341 {
342 u_long *retval;
343 size_t retval_len = 0;
344 retval =
345 get_ipCidrRouteNextHop(data_context, &retval_len);
346 snmp_set_var_typed_value(var, ASN_IPADDRESS,
347 (const u_char *) retval,
348 retval_len);
349 }
350 break;
351
352 case COLUMN_IPCIDRROUTEIFINDEX:
353 {
354 long *retval;
355 size_t retval_len = 0;
356 retval =
357 get_ipCidrRouteIfIndex(data_context, &retval_len);
358 snmp_set_var_typed_value(var, ASN_INTEGER,
359 (const u_char *) retval,
360 retval_len);
361 }
362 break;
363
364 case COLUMN_IPCIDRROUTETYPE:
365 {
366 long *retval;
367 size_t retval_len = 0;
368 retval =
369 get_ipCidrRouteType(data_context, &retval_len);
370 snmp_set_var_typed_value(var, ASN_INTEGER,
371 (const u_char *) retval,
372 retval_len);
373 }
374 break;
375
376 case COLUMN_IPCIDRROUTEPROTO:
377 {
378 long *retval;
379 size_t retval_len = 0;
380 retval =
381 get_ipCidrRouteProto(data_context, &retval_len);
382 snmp_set_var_typed_value(var, ASN_INTEGER,
383 (const u_char *) retval,
384 retval_len);
385 }
386 break;
387
388 case COLUMN_IPCIDRROUTEAGE:
389 {
390 long *retval;
391 size_t retval_len = 0;
392 retval = get_ipCidrRouteAge(data_context, &retval_len);
393 snmp_set_var_typed_value(var, ASN_INTEGER,
394 (const u_char *) retval,
395 retval_len);
396 }
397 break;
398
399 case COLUMN_IPCIDRROUTEINFO:
400 {
401 oid *retval;
402 size_t retval_len = 0;
403 retval =
404 get_ipCidrRouteInfo(data_context, &retval_len);
405 snmp_set_var_typed_value(var, ASN_OBJECT_ID,
406 (const u_char *) retval,
407 retval_len);
408 }
409 break;
410
411 case COLUMN_IPCIDRROUTENEXTHOPAS:
412 {
413 long *retval;
414 size_t retval_len = 0;
415 retval =
416 get_ipCidrRouteNextHopAS(data_context,
417 &retval_len);
418 snmp_set_var_typed_value(var, ASN_INTEGER,
419 (const u_char *) retval,
420 retval_len);
421 }
422 break;
423
424 case COLUMN_IPCIDRROUTEMETRIC1:
425 {
426 long *retval;
427 size_t retval_len = 0;
428 retval =
429 get_ipCidrRouteMetric1(data_context, &retval_len);
430 snmp_set_var_typed_value(var, ASN_INTEGER,
431 (const u_char *) retval,
432 retval_len);
433 }
434 break;
435
436 case COLUMN_IPCIDRROUTEMETRIC2:
437 {
438 long *retval;
439 size_t retval_len = 0;
440 retval =
441 get_ipCidrRouteMetric2(data_context, &retval_len);
442 snmp_set_var_typed_value(var, ASN_INTEGER,
443 (const u_char *) retval,
444 retval_len);
445 }
446 break;
447
448 case COLUMN_IPCIDRROUTEMETRIC3:
449 {
450 long *retval;
451 size_t retval_len = 0;
452 retval =
453 get_ipCidrRouteMetric3(data_context, &retval_len);
454 snmp_set_var_typed_value(var, ASN_INTEGER,
455 (const u_char *) retval,
456 retval_len);
457 }
458 break;
459
460 case COLUMN_IPCIDRROUTEMETRIC4:
461 {
462 long *retval;
463 size_t retval_len = 0;
464 retval =
465 get_ipCidrRouteMetric4(data_context, &retval_len);
466 snmp_set_var_typed_value(var, ASN_INTEGER,
467 (const u_char *) retval,
468 retval_len);
469 }
470 break;
471
472 case COLUMN_IPCIDRROUTEMETRIC5:
473 {
474 long *retval;
475 size_t retval_len = 0;
476 retval =
477 get_ipCidrRouteMetric5(data_context, &retval_len);
478 snmp_set_var_typed_value(var, ASN_INTEGER,
479 (const u_char *) retval,
480 retval_len);
481 }
482 break;
483
484 case COLUMN_IPCIDRROUTESTATUS:
485 {
486 long *retval;
487 size_t retval_len = 0;
488 retval =
489 get_ipCidrRouteStatus(data_context, &retval_len);
490 snmp_set_var_typed_value(var, ASN_INTEGER,
491 (const u_char *) retval,
492 retval_len);
493 }
494 break;
495
496 default:
497 /** We shouldn't get here */
498 snmp_log(LOG_ERR,
499 "problem encountered in ipCidrRouteTable_handler: unknown column\n");
500 }
501 break;
502
503 case MODE_SET_RESERVE1:
504 /** mib2cXXX: clear out old undo info if we have any. Remove if
505 table_iterator becomes un-serialized */
506 netsnmp_oid_stash_free(&undoStorage, free_undoInfo);
507
508 switch (table_info->colnum) {
509 case COLUMN_IPCIDRROUTEIFINDEX:
510 {
511 int ret =
512 check_ipCidrRouteIfIndex(request->requestvb->type,
513 (long *) request->
514 requestvb->val.string,
515 request->requestvb->
516 val_len);
517 if (ret != 0) {
518 netsnmp_set_request_error(reqinfo, requests, ret);
519 }
520 }
521 break;
522 case COLUMN_IPCIDRROUTETYPE:
523 {
524 int ret =
525 check_ipCidrRouteType(request->requestvb->type,
526 (long *) request->requestvb->
527 val.string,
528 request->requestvb->val_len);
529 if (ret != 0) {
530 netsnmp_set_request_error(reqinfo, requests, ret);
531 }
532 }
533 break;
534 case COLUMN_IPCIDRROUTEINFO:
535 {
536 int ret =
537 check_ipCidrRouteInfo(request->requestvb->type,
538 (oid *) request->requestvb->
539 val.string,
540 request->requestvb->val_len);
541 if (ret != 0) {
542 netsnmp_set_request_error(reqinfo, requests, ret);
543 }
544 }
545 break;
546 case COLUMN_IPCIDRROUTENEXTHOPAS:
547 {
548 int ret =
549 check_ipCidrRouteNextHopAS(request->requestvb->
550 type,
551 (long *) request->
552 requestvb->val.string,
553 request->requestvb->
554 val_len);
555 if (ret != 0) {
556 netsnmp_set_request_error(reqinfo, requests, ret);
557 }
558 }
559 break;
560 case COLUMN_IPCIDRROUTEMETRIC1:
561 {
562 int ret =
563 check_ipCidrRouteMetric1(request->requestvb->type,
564 (long *) request->
565 requestvb->val.string,
566 request->requestvb->
567 val_len);
568 if (ret != 0) {
569 netsnmp_set_request_error(reqinfo, requests, ret);
570 }
571 }
572 break;
573 case COLUMN_IPCIDRROUTEMETRIC2:
574 {
575 int ret =
576 check_ipCidrRouteMetric2(request->requestvb->type,
577 (long *) request->
578 requestvb->val.string,
579 request->requestvb->
580 val_len);
581 if (ret != 0) {
582 netsnmp_set_request_error(reqinfo, requests, ret);
583 }
584 }
585 break;
586 case COLUMN_IPCIDRROUTEMETRIC3:
587 {
588 int ret =
589 check_ipCidrRouteMetric3(request->requestvb->type,
590 (long *) request->
591 requestvb->val.string,
592 request->requestvb->
593 val_len);
594 if (ret != 0) {
595 netsnmp_set_request_error(reqinfo, requests, ret);
596 }
597 }
598 break;
599 case COLUMN_IPCIDRROUTEMETRIC4:
600 {
601 int ret =
602 check_ipCidrRouteMetric4(request->requestvb->type,
603 (long *) request->
604 requestvb->val.string,
605 request->requestvb->
606 val_len);
607 if (ret != 0) {
608 netsnmp_set_request_error(reqinfo, requests, ret);
609 }
610 }
611 break;
612 case COLUMN_IPCIDRROUTEMETRIC5:
613 {
614 int ret =
615 check_ipCidrRouteMetric5(request->requestvb->type,
616 (long *) request->
617 requestvb->val.string,
618 request->requestvb->
619 val_len);
620 if (ret != 0) {
621 netsnmp_set_request_error(reqinfo, requests, ret);
622 }
623 }
624 break;
625 case COLUMN_IPCIDRROUTESTATUS:
626 {
627 int ret =
628 check_ipCidrRouteStatus(request->requestvb->type,
629 (long *) request->
630 requestvb->val.string,
631 request->requestvb->
632 val_len);
633 if (ret != 0) {
634 netsnmp_set_request_error(reqinfo, requests, ret);
635 }
636 }
637 break;
638 default:
639 netsnmp_set_request_error(reqinfo, requests,
640 SNMP_ERR_NOTWRITABLE);
641 break;
642 }
643 break;
644
645 case MODE_SET_RESERVE2:
646 /** save a variable copy */
647 switch (table_info->colnum) {
648 case COLUMN_IPCIDRROUTEIFINDEX:
649 {
650 long *retval;
651 size_t retval_len = 0;
652 struct undoInfo *ui;
653 retval =
654 get_ipCidrRouteIfIndex(data_context, &retval_len);
655 if (retval) {
656 ui = SNMP_MALLOC_STRUCT(undoInfo);
657 ui->len = retval_len;
658 ui->ptr = netsnmp_memdup(retval, ui->len);
659 netsnmp_oid_stash_add_data(&undoStorage,
660 suffix, suffix_len, ui);
661 }
662 }
663 break;
664 case COLUMN_IPCIDRROUTETYPE:
665 {
666 long *retval;
667 size_t retval_len = 0;
668 struct undoInfo *ui;
669 retval =
670 get_ipCidrRouteType(data_context, &retval_len);
671 if (retval) {
672 ui = SNMP_MALLOC_STRUCT(undoInfo);
673 ui->len = retval_len;
674 ui->ptr = netsnmp_memdup(retval, ui->len);
675 netsnmp_oid_stash_add_data(&undoStorage,
676 suffix, suffix_len, ui);
677 }
678 }
679 break;
680 case COLUMN_IPCIDRROUTEINFO:
681 {
682 oid *retval;
683 size_t retval_len = 0;
684 struct undoInfo *ui;
685 retval =
686 get_ipCidrRouteInfo(data_context, &retval_len);
687 if (retval) {
688 ui = SNMP_MALLOC_STRUCT(undoInfo);
689 ui->len = retval_len;
690 ui->ptr = netsnmp_memdup(retval, ui->len);
691 netsnmp_oid_stash_add_data(&undoStorage,
692 suffix, suffix_len, ui);
693 }
694 }
695 break;
696 case COLUMN_IPCIDRROUTENEXTHOPAS:
697 {
698 long *retval;
699 size_t retval_len = 0;
700 struct undoInfo *ui;
701 retval =
702 get_ipCidrRouteNextHopAS(data_context,
703 &retval_len);
704 if (retval) {
705 ui = SNMP_MALLOC_STRUCT(undoInfo);
706 ui->len = retval_len;
707 ui->ptr = netsnmp_memdup(retval, ui->len);
708 netsnmp_oid_stash_add_data(&undoStorage,
709 suffix, suffix_len, ui);
710 }
711 }
712 break;
713 case COLUMN_IPCIDRROUTEMETRIC1:
714 {
715 long *retval;
716 size_t retval_len = 0;
717 struct undoInfo *ui;
718 retval =
719 get_ipCidrRouteMetric1(data_context, &retval_len);
720 if (retval) {
721 ui = SNMP_MALLOC_STRUCT(undoInfo);
722 ui->len = retval_len;
723 ui->ptr = netsnmp_memdup(retval, ui->len);
724 netsnmp_oid_stash_add_data(&undoStorage,
725 suffix, suffix_len, ui);
726 }
727 }
728 break;
729 case COLUMN_IPCIDRROUTEMETRIC2:
730 {
731 long *retval;
732 size_t retval_len = 0;
733 struct undoInfo *ui;
734 retval =
735 get_ipCidrRouteMetric2(data_context, &retval_len);
736 if (retval) {
737 ui = SNMP_MALLOC_STRUCT(undoInfo);
738 ui->len = retval_len;
739 ui->ptr = netsnmp_memdup(retval, ui->len);
740 netsnmp_oid_stash_add_data(&undoStorage,
741 suffix, suffix_len, ui);
742 }
743 }
744 break;
745 case COLUMN_IPCIDRROUTEMETRIC3:
746 {
747 long *retval;
748 size_t retval_len = 0;
749 struct undoInfo *ui;
750 retval =
751 get_ipCidrRouteMetric3(data_context, &retval_len);
752 if (retval) {
753 ui = SNMP_MALLOC_STRUCT(undoInfo);
754 ui->len = retval_len;
755 ui->ptr = netsnmp_memdup(retval, ui->len);
756 netsnmp_oid_stash_add_data(&undoStorage,
757 suffix, suffix_len, ui);
758 }
759 }
760 break;
761 case COLUMN_IPCIDRROUTEMETRIC4:
762 {
763 long *retval;
764 size_t retval_len = 0;
765 struct undoInfo *ui;
766 retval =
767 get_ipCidrRouteMetric4(data_context, &retval_len);
768 if (retval) {
769 ui = SNMP_MALLOC_STRUCT(undoInfo);
770 ui->len = retval_len;
771 ui->ptr = netsnmp_memdup(retval, ui->len);
772 netsnmp_oid_stash_add_data(&undoStorage,
773 suffix, suffix_len, ui);
774 }
775 }
776 break;
777 case COLUMN_IPCIDRROUTEMETRIC5:
778 {
779 long *retval;
780 size_t retval_len = 0;
781 struct undoInfo *ui;
782 retval =
783 get_ipCidrRouteMetric5(data_context, &retval_len);
784 if (retval) {
785 ui = SNMP_MALLOC_STRUCT(undoInfo);
786 ui->len = retval_len;
787 ui->ptr = netsnmp_memdup(retval, ui->len);
788 netsnmp_oid_stash_add_data(&undoStorage,
789 suffix, suffix_len, ui);
790 }
791 }
792 break;
793 case COLUMN_IPCIDRROUTESTATUS:
794 {
795 long *retval;
796 size_t retval_len = 0;
797 struct undoInfo *ui;
798 retval =
799 get_ipCidrRouteStatus(data_context, &retval_len);
800 if (retval) {
801 ui = SNMP_MALLOC_STRUCT(undoInfo);
802 ui->len = retval_len;
803 ui->ptr = netsnmp_memdup(retval, ui->len);
804 netsnmp_oid_stash_add_data(&undoStorage,
805 suffix, suffix_len, ui);
806 }
807 }
808 break;
809 }
810 break;
811
812 case MODE_SET_FREE:
813 /** Forget undo data, if exists */
814 netsnmp_oid_stash_free(&undoStorage, free_undoInfo);
815 break;
816
817 case MODE_SET_ACTION:
818 /** save a variable copy */
819 switch (table_info->colnum) {
820 case COLUMN_IPCIDRROUTEIFINDEX:
821 {
822 int ret =
823 set_ipCidrRouteIfIndex(data_context,
824 (long *) request->
825 requestvb->val.string,
826 request->requestvb->
827 val_len);
828 if (ret) {
829 netsnmp_set_request_error(reqinfo, requests, ret);
830 }
831 }
832 break;
833 case COLUMN_IPCIDRROUTETYPE:
834 {
835 int ret = set_ipCidrRouteType(data_context,
836 (long *)
837 request->
838 requestvb->
839 val.string,
840 request->
841 requestvb->
842 val_len);
843 if (ret) {
844 netsnmp_set_request_error(reqinfo, requests, ret);
845 }
846 }
847 break;
848 case COLUMN_IPCIDRROUTEINFO:
849 {
850 int ret = set_ipCidrRouteInfo(data_context,
851 (oid *)
852 request->
853 requestvb->
854 val.string,
855 request->
856 requestvb->
857 val_len);
858 if (ret) {
859 netsnmp_set_request_error(reqinfo, requests, ret);
860 }
861 }
862 break;
863 case COLUMN_IPCIDRROUTENEXTHOPAS:
864 {
865 int ret =
866 set_ipCidrRouteNextHopAS(data_context,
867 (long *) request->
868 requestvb->val.string,
869 request->requestvb->
870 val_len);
871 if (ret) {
872 netsnmp_set_request_error(reqinfo, requests, ret);
873 }
874 }
875 break;
876 case COLUMN_IPCIDRROUTEMETRIC1:
877 {
878 int ret =
879 set_ipCidrRouteMetric1(data_context,
880 (long *) request->
881 requestvb->val.string,
882 request->requestvb->
883 val_len);
884 if (ret) {
885 netsnmp_set_request_error(reqinfo, requests, ret);
886 }
887 }
888 break;
889 case COLUMN_IPCIDRROUTEMETRIC2:
890 {
891 int ret =
892 set_ipCidrRouteMetric2(data_context,
893 (long *) request->
894 requestvb->val.string,
895 request->requestvb->
896 val_len);
897 if (ret) {
898 netsnmp_set_request_error(reqinfo, requests, ret);
899 }
900 }
901 break;
902 case COLUMN_IPCIDRROUTEMETRIC3:
903 {
904 int ret =
905 set_ipCidrRouteMetric3(data_context,
906 (long *) request->
907 requestvb->val.string,
908 request->requestvb->
909 val_len);
910 if (ret) {
911 netsnmp_set_request_error(reqinfo, requests, ret);
912 }
913 }
914 break;
915 case COLUMN_IPCIDRROUTEMETRIC4:
916 {
917 int ret =
918 set_ipCidrRouteMetric4(data_context,
919 (long *) request->
920 requestvb->val.string,
921 request->requestvb->
922 val_len);
923 if (ret) {
924 netsnmp_set_request_error(reqinfo, requests, ret);
925 }
926 }
927 break;
928 case COLUMN_IPCIDRROUTEMETRIC5:
929 {
930 int ret =
931 set_ipCidrRouteMetric5(data_context,
932 (long *) request->
933 requestvb->val.string,
934 request->requestvb->
935 val_len);
936 if (ret) {
937 netsnmp_set_request_error(reqinfo, requests, ret);
938 }
939 }
940 break;
941 case COLUMN_IPCIDRROUTESTATUS:
942 {
943 int ret =
944 set_ipCidrRouteStatus(data_context,
945 (long *) request->requestvb->
946 val.string,
947 request->requestvb->val_len);
948 if (ret) {
949 netsnmp_set_request_error(reqinfo, requests, ret);
950 }
951 }
952 break;
953 }
954 break;
955
956 case MODE_SET_COMMIT:
957 /** answers were all good. Forget undo data */
958 netsnmp_oid_stash_free(&undoStorage, free_undoInfo);
959 /** mib2cXXX: call commit hook */
960 break;
961
962 case MODE_SET_UNDO:
963 /** save a variable copy */
964 switch (table_info->colnum) {
965 case COLUMN_IPCIDRROUTEIFINDEX:
966 {
967 int retval;
968 struct undoInfo *ui;
969 ui = netsnmp_oid_stash_get_data(undoStorage,
970 suffix, suffix_len);
971 retval =
972 set_ipCidrRouteIfIndex(data_context, ui->ptr,
973 ui->len);
974 if (retval) {
975 netsnmp_set_request_error(reqinfo, requests,
976 SNMP_ERR_UNDOFAILED);
977 }
978 }
979 break;
980 case COLUMN_IPCIDRROUTETYPE:
981 {
982 int retval;
983 struct undoInfo *ui;
984 ui = netsnmp_oid_stash_get_data(undoStorage,
985 suffix, suffix_len);
986 retval =
987 set_ipCidrRouteType(data_context, ui->ptr,
988 ui->len);
989 if (retval) {
990 netsnmp_set_request_error(reqinfo, requests,
991 SNMP_ERR_UNDOFAILED);
992 }
993 }
994 break;
995 case COLUMN_IPCIDRROUTEINFO:
996 {
997 int retval;
998 struct undoInfo *ui;
999 ui = netsnmp_oid_stash_get_data(undoStorage,
1000 suffix, suffix_len);
1001 retval =
1002 set_ipCidrRouteInfo(data_context, ui->ptr,
1003 ui->len);
1004 if (retval) {
1005 netsnmp_set_request_error(reqinfo, requests,
1006 SNMP_ERR_UNDOFAILED);
1007 }
1008 }
1009 break;
1010 case COLUMN_IPCIDRROUTENEXTHOPAS:
1011 {
1012 int retval;
1013 struct undoInfo *ui;
1014 ui = netsnmp_oid_stash_get_data(undoStorage,
1015 suffix, suffix_len);
1016 retval =
1017 set_ipCidrRouteNextHopAS(data_context, ui->ptr,
1018 ui->len);
1019 if (retval) {
1020 netsnmp_set_request_error(reqinfo, requests,
1021 SNMP_ERR_UNDOFAILED);
1022 }
1023 }
1024 break;
1025 case COLUMN_IPCIDRROUTEMETRIC1:
1026 {
1027 int retval;
1028 struct undoInfo *ui;
1029 ui = netsnmp_oid_stash_get_data(undoStorage,
1030 suffix, suffix_len);
1031 retval =
1032 set_ipCidrRouteMetric1(data_context, ui->ptr,
1033 ui->len);
1034 if (retval) {
1035 netsnmp_set_request_error(reqinfo, requests,
1036 SNMP_ERR_UNDOFAILED);
1037 }
1038 }
1039 break;
1040 case COLUMN_IPCIDRROUTEMETRIC2:
1041 {
1042 int retval;
1043 struct undoInfo *ui;
1044 ui = netsnmp_oid_stash_get_data(undoStorage,
1045 suffix, suffix_len);
1046 retval =
1047 set_ipCidrRouteMetric2(data_context, ui->ptr,
1048 ui->len);
1049 if (retval) {
1050 netsnmp_set_request_error(reqinfo, requests,
1051 SNMP_ERR_UNDOFAILED);
1052 }
1053 }
1054 break;
1055 case COLUMN_IPCIDRROUTEMETRIC3:
1056 {
1057 int retval;
1058 struct undoInfo *ui;
1059 ui = netsnmp_oid_stash_get_data(undoStorage,
1060 suffix, suffix_len);
1061 retval =
1062 set_ipCidrRouteMetric3(data_context, ui->ptr,
1063 ui->len);
1064 if (retval) {
1065 netsnmp_set_request_error(reqinfo, requests,
1066 SNMP_ERR_UNDOFAILED);
1067 }
1068 }
1069 break;
1070 case COLUMN_IPCIDRROUTEMETRIC4:
1071 {
1072 int retval;
1073 struct undoInfo *ui;
1074 ui = netsnmp_oid_stash_get_data(undoStorage,
1075 suffix, suffix_len);
1076 retval =
1077 set_ipCidrRouteMetric4(data_context, ui->ptr,
1078 ui->len);
1079 if (retval) {
1080 netsnmp_set_request_error(reqinfo, requests,
1081 SNMP_ERR_UNDOFAILED);
1082 }
1083 }
1084 break;
1085 case COLUMN_IPCIDRROUTEMETRIC5:
1086 {
1087 int retval;
1088 struct undoInfo *ui;
1089 ui = netsnmp_oid_stash_get_data(undoStorage,
1090 suffix, suffix_len);
1091 retval =
1092 set_ipCidrRouteMetric5(data_context, ui->ptr,
1093 ui->len);
1094 if (retval) {
1095 netsnmp_set_request_error(reqinfo, requests,
1096 SNMP_ERR_UNDOFAILED);
1097 }
1098 }
1099 break;
1100 case COLUMN_IPCIDRROUTESTATUS:
1101 {
1102 int retval;
1103 struct undoInfo *ui;
1104 ui = netsnmp_oid_stash_get_data(undoStorage,
1105 suffix, suffix_len);
1106 retval =
1107 set_ipCidrRouteStatus(data_context, ui->ptr,
1108 ui->len);
1109 if (retval) {
1110 netsnmp_set_request_error(reqinfo, requests,
1111 SNMP_ERR_UNDOFAILED);
1112 }
1113 }
1114 break;
1115 }
1116 /** mib2cXXX: remove cache! hard to do when serialized, however */
1117 break;
1118
1119 default:
1120 snmp_log(LOG_ERR,
1121 "problem encountered in ipCidrRouteTable_handler: unsupported mode\n");
1122 }
1123 }
1124 return SNMP_ERR_NOERROR;
1125 }