Debian Codegraph @

agent/mibgroup/examples/netSnmpHostsTable.c

raw
1 /*
2 * Note: this file originally auto-generated by mib2c using
3 * : mib2c.iterate_access.conf,v 1.4 2003/07/01 00:15:11 hardaker Exp $
4 */
5
6 #include <net-snmp/net-snmp-config.h>
7 #include <net-snmp/net-snmp-features.h>
8 #include <net-snmp/net-snmp-includes.h>
9 #include <net-snmp/agent/net-snmp-agent-includes.h>
10 #include "netSnmpHostsTable.h"
11 #include "netSnmpHostsTable_checkfns.h"
12 #include "netSnmpHostsTable_access.h"
13
14 netsnmp_feature_require(oid_stash);
15 netsnmp_feature_require(oid_stash_get_data);
16 netsnmp_feature_require(oid_stash_add_data);
17
18 static netsnmp_oid_stash_node *undoStorage = NULL;
19 static netsnmp_oid_stash_node *commitStorage = NULL;
20
21 struct undoInfo {
22 void *ptr;
23 size_t len;
24 };
25
26 struct commitInfo {
27 void *data_context;
28 int have_committed;
29 int new_row;
30 };
31
32 void
33 netSnmpHostsTable_free_undoInfo(void *vptr)
34 {
35 struct undoInfo *ui = vptr;
36 if (!ui)
37 return;
38 SNMP_FREE(ui->ptr);
39 SNMP_FREE(ui);
40 }
41
42 /** Initialize the netSnmpHostsTable table by defining its contents and how it's structured */
43 void
44 initialize_table_netSnmpHostsTable(void)
45 {
46 static oid netSnmpHostsTable_oid[] =
47 { 1, 3, 6, 1, 4, 1, 8072, 2, 2, 2 };
48 netsnmp_table_registration_info *table_info;
49 netsnmp_handler_registration *my_handler;
50 netsnmp_iterator_info *iinfo;
51
52 /** create the table registration information structures */
53 table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
54 iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info);
55
56 /** if your table is read only, it's easiest to change the
57 HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */
58 my_handler = netsnmp_create_handler_registration("netSnmpHostsTable",
59 netSnmpHostsTable_handler,
60 netSnmpHostsTable_oid,
61 OID_LENGTH
62 (netSnmpHostsTable_oid),
63 HANDLER_CAN_RWRITE);
64
65 if (!my_handler || !table_info || !iinfo) {
66 snmp_log(LOG_ERR,
67 "malloc failed in initialize_table_netSnmpHostsTable");
68 free(my_handler);
69 free(table_info);
70 free(iinfo);
71 return; /** Serious error. */
72 }
73
74 /***************************************************
75 * Setting up the table's definition
76 */
77 netsnmp_table_helper_add_indexes(table_info, ASN_OCTET_STR,
78 /** index: netSnmpHostName */
79 0);
80
81 /** Define the minimum and maximum accessible columns. This
82 optimizes retrieval. */
83 table_info->min_column = 2;
84 table_info->max_column = 5;
85
86 /** iterator access routines */
87 iinfo->get_first_data_point = netSnmpHostsTable_get_first_data_point;
88 iinfo->get_next_data_point = netSnmpHostsTable_get_next_data_point;
89
90 /** you may wish to set these as well */
91 iinfo->make_data_context = netSnmpHostsTable_context_convert_function;
92 iinfo->free_data_context = netSnmpHostsTable_data_free;
93 iinfo->free_loop_context_at_end = netSnmpHostsTable_loop_free;
94
95 /** tie the two structures together */
96 iinfo->table_reginfo = table_info;
97
98 /***************************************************
99 * registering the table with the master agent
100 */
101 DEBUGMSGTL(("initialize_table_netSnmpHostsTable",
102 "Registering table netSnmpHostsTable as a table iterator\n"));
103 netsnmp_register_table_iterator2(my_handler, iinfo);
104 }
105
106 /** Initializes the netSnmpHostsTable module */
107 void
108 init_netSnmpHostsTable(void)
109 {
110
111 /** here we initialize all the tables we're planning on supporting */
112 initialize_table_netSnmpHostsTable();
113 }
114
115 /** handles requests for the netSnmpHostsTable table, if anything else needs to be done */
116 int
117 netSnmpHostsTable_handler(netsnmp_mib_handler *handler,
118 netsnmp_handler_registration *reginfo,
119 netsnmp_agent_request_info *reqinfo,
120 netsnmp_request_info *requests)
121 {
122
123 netsnmp_request_info *request;
124 netsnmp_table_request_info *table_info;
125 struct commitInfo *ci = NULL;
126
127 void *data_context = NULL;
128
129 for (request = requests; request; request = request->next) {
130 /* column and row index encoded portion */
131 netsnmp_variable_list *var = request->requestvb;
132 const oid * const suffix = var->name + reginfo->rootoid_len + 1;
133 const size_t suffix_len = var->name_length - (reginfo->rootoid_len + 1);
134
135 if (request->processed != 0)
136 continue;
137
138 switch (reqinfo->mode) {
139 case MODE_GET:
140 case MODE_SET_RESERVE1:
141 data_context = netsnmp_extract_iterator_context(request);
142 if (data_context == NULL) {
143 if (reqinfo->mode == MODE_GET) {
144 netsnmp_set_request_error(reqinfo, request,
145 SNMP_NOSUCHINSTANCE);
146 continue;
147 }
148 }
149 break;
150
151 default: /* == the other SET modes */
152 ci = netsnmp_oid_stash_get_data(commitStorage,
153 suffix + 1, suffix_len - 1);
154 break;
155
156 }
157
158 /** extracts the information about the table from the request */
159 table_info = netsnmp_extract_table_info(request);
160 /** table_info->colnum contains the column number requested */
161 /** table_info->indexes contains a linked list of snmp variable
162 bindings for the indexes of the table. Values in the list
163 have been set corresponding to the indexes of the
164 request */
165 if (table_info == NULL) {
166 continue;
167 }
168
169 switch (reqinfo->mode) {
170 case MODE_GET:
171 switch (table_info->colnum) {
172 case COLUMN_NETSNMPHOSTADDRESSTYPE:
173 {
174 long *retval;
175 size_t retval_len = 0;
176 retval =
177 get_netSnmpHostAddressType(data_context,
178 &retval_len);
179 snmp_set_var_typed_value(var, ASN_INTEGER,
180 (const u_char *) retval,
181 retval_len);
182 }
183 break;
184
185 case COLUMN_NETSNMPHOSTADDRESS:
186 {
187 char *retval;
188 size_t retval_len = 0;
189 retval =
190 get_netSnmpHostAddress(data_context, &retval_len);
191 snmp_set_var_typed_value(var, ASN_OCTET_STR,
192 (const u_char *) retval,
193 retval_len);
194 }
195 break;
196
197 case COLUMN_NETSNMPHOSTSTORAGE:
198 {
199 long *retval;
200 size_t retval_len = 0;
201 retval =
202 get_netSnmpHostStorage(data_context, &retval_len);
203 snmp_set_var_typed_value(var, ASN_INTEGER,
204 (const u_char *) retval,
205 retval_len);
206 }
207 break;
208
209 case COLUMN_NETSNMPHOSTROWSTATUS:
210 {
211 long *retval;
212 size_t retval_len = 0;
213 retval =
214 get_netSnmpHostRowStatus(data_context,
215 &retval_len);
216 snmp_set_var_typed_value(var, ASN_INTEGER,
217 (const u_char *) retval,
218 retval_len);
219 }
220 break;
221
222 default:
223 /** We shouldn't get here */
224 snmp_log(LOG_ERR,
225 "problem encountered in netSnmpHostsTable_handler: unknown column\n");
226 }
227 break;
228
229 case MODE_SET_RESERVE1:
230 ci = netsnmp_oid_stash_get_data(commitStorage,
231 suffix + 1, suffix_len - 1);
232
233 if (!ci) {
234 /** create the commit storage info */
235 ci = SNMP_MALLOC_STRUCT(commitInfo);
236 if (!data_context) {
237 ci->data_context =
238 netSnmpHostsTable_create_data_context(table_info->
239 indexes);
240 ci->new_row = 1;
241 } else {
242 ci->data_context = data_context;
243 }
244 netsnmp_oid_stash_add_data(&commitStorage,
245 suffix + 1, suffix_len - 1, ci);
246 }
247 break;
248
249 case MODE_SET_RESERVE2:
250 switch (table_info->colnum) {
251 case COLUMN_NETSNMPHOSTADDRESSTYPE:
252 {
253 long *retval;
254 size_t retval_len = 0;
255 struct undoInfo *ui = NULL;
256 int ret;
257
258 /** first, get the old value */
259 retval =
260 get_netSnmpHostAddressType(ci->data_context,
261 &retval_len);
262 if (retval) {
263 ui = SNMP_MALLOC_STRUCT(undoInfo);
264 ui->len = retval_len;
265 ui->ptr = netsnmp_memdup(retval, ui->len);
266 }
267
268 /** check the new value, possibly against the
269 older value for a valid state transition */
270 ret =
271 check_netSnmpHostAddressType(request->requestvb->
272 type,
273 (long *) request->
274 requestvb->val.string,
275 request->requestvb->
276 val_len, retval,
277 retval_len);
278 if (ret != 0) {
279 netsnmp_set_request_error(reqinfo, request, ret);
280 netSnmpHostsTable_free_undoInfo(ui);
281 } else if (ui) {
282 /** remember information for undo purposes later */
283 netsnmp_oid_stash_add_data(&undoStorage,
284 suffix, suffix_len, ui);
285 }
286
287 }
288 break;
289 case COLUMN_NETSNMPHOSTADDRESS:
290 {
291 char *retval;
292 size_t retval_len = 0;
293 struct undoInfo *ui = NULL;
294 int ret;
295
296 /** first, get the old value */
297 retval =
298 get_netSnmpHostAddress(ci->data_context,
299 &retval_len);
300 if (retval) {
301 ui = SNMP_MALLOC_STRUCT(undoInfo);
302 ui->len = retval_len;
303 ui->ptr = netsnmp_memdup(retval, ui->len);
304 }
305
306 /** check the new value, possibly against the
307 older value for a valid state transition */
308 ret =
309 check_netSnmpHostAddress(request->requestvb->type,
310 (char *) request->
311 requestvb->val.string,
312 request->requestvb->
313 val_len, retval,
314 retval_len);
315 if (ret != 0) {
316 netsnmp_set_request_error(reqinfo, request, ret);
317 netSnmpHostsTable_free_undoInfo(ui);
318 } else if (ui) {
319 /** remember information for undo purposes later */
320 netsnmp_oid_stash_add_data(&undoStorage,
321 suffix, suffix_len, ui);
322 }
323
324 }
325 break;
326 case COLUMN_NETSNMPHOSTSTORAGE:
327 {
328 long *retval;
329 size_t retval_len = 0;
330 struct undoInfo *ui = NULL;
331 int ret;
332
333 /** first, get the old value */
334 retval =
335 get_netSnmpHostStorage(ci->data_context,
336 &retval_len);
337 if (retval) {
338 ui = SNMP_MALLOC_STRUCT(undoInfo);
339 ui->len = retval_len;
340 ui->ptr = netsnmp_memdup(retval, ui->len);
341 }
342
343 /** check the new value, possibly against the
344 older value for a valid state transition */
345 ret =
346 check_netSnmpHostStorage(request->requestvb->type,
347 (long *) request->
348 requestvb->val.string,
349 request->requestvb->
350 val_len, retval,
351 retval_len);
352 if (ret != 0) {
353 netsnmp_set_request_error(reqinfo, request, ret);
354 netSnmpHostsTable_free_undoInfo(ui);
355 } else if (ui) {
356 /** remember information for undo purposes later */
357 netsnmp_oid_stash_add_data(&undoStorage,
358 suffix, suffix_len, ui);
359 }
360
361 }
362 break;
363 case COLUMN_NETSNMPHOSTROWSTATUS:
364 {
365 long *retval;
366 size_t retval_len = 0;
367 struct undoInfo *ui = NULL;
368 int ret;
369
370 /** first, get the old value */
371 retval =
372 get_netSnmpHostRowStatus(ci->data_context,
373 &retval_len);
374 if (retval) {
375 ui = SNMP_MALLOC_STRUCT(undoInfo);
376 ui->len = retval_len;
377 ui->ptr = netsnmp_memdup(retval, ui->len);
378 }
379
380 /** check the new value, possibly against the
381 older value for a valid state transition */
382 ret =
383 check_netSnmpHostRowStatus(request->requestvb->
384 type,
385 (long *) request->
386 requestvb->val.string,
387 request->requestvb->
388 val_len, retval,
389 retval_len);
390 if (ret != 0) {
391 netsnmp_set_request_error(reqinfo, request, ret);
392 netSnmpHostsTable_free_undoInfo(ui);
393 } else if (ui) {
394 /** remember information for undo purposes later */
395 netsnmp_oid_stash_add_data(&undoStorage,
396 suffix, suffix_len, ui);
397 }
398
399 }
400 break;
401 default:
402 netsnmp_set_request_error(reqinfo, request,
403 SNMP_ERR_NOTWRITABLE);
404 break;
405 }
406 break;
407
408 case MODE_SET_ACTION:
409 /** save a variable copy */
410 switch (table_info->colnum) {
411 case COLUMN_NETSNMPHOSTADDRESSTYPE:
412 {
413 int ret;
414 ret = set_netSnmpHostAddressType(ci->data_context,
415 (long *) request->
416 requestvb->val.string,
417 request->requestvb->
418 val_len);
419 if (ret) {
420 netsnmp_set_request_error(reqinfo, request, ret);
421 }
422 }
423 break;
424 case COLUMN_NETSNMPHOSTADDRESS:
425 {
426 int ret;
427 ret = set_netSnmpHostAddress(ci->data_context,
428 (char *) request->
429 requestvb->val.string,
430 request->requestvb->
431 val_len);
432 if (ret) {
433 netsnmp_set_request_error(reqinfo, request, ret);
434 }
435 }
436 break;
437 case COLUMN_NETSNMPHOSTSTORAGE:
438 {
439 int ret;
440 ret = set_netSnmpHostStorage(ci->data_context,
441 (long *) request->
442 requestvb->val.string,
443 request->requestvb->
444 val_len);
445 if (ret) {
446 netsnmp_set_request_error(reqinfo, request, ret);
447 }
448 }
449 break;
450 case COLUMN_NETSNMPHOSTROWSTATUS:
451 {
452 int ret;
453 ret = set_netSnmpHostRowStatus(ci->data_context,
454 (long *) request->
455 requestvb->val.string,
456 request->requestvb->
457 val_len);
458 if (ret) {
459 netsnmp_set_request_error(reqinfo, request, ret);
460 }
461 if (*request->requestvb->val.integer == RS_DESTROY) {
462 ci->new_row = -1;
463 }
464 }
465 break;
466 }
467 break;
468
469 case MODE_SET_COMMIT:
470 if (!ci->have_committed) {
471 /** do this once per row only */
472 netSnmpHostsTable_commit_row(&ci->data_context,
473 ci->new_row);
474 ci->have_committed = 1;
475 }
476 break;
477
478 case MODE_SET_UNDO:
479 /** save a variable copy */
480 switch (table_info->colnum) {
481 case COLUMN_NETSNMPHOSTADDRESSTYPE:
482 {
483 int retval;
484 struct undoInfo *ui;
485 ui = netsnmp_oid_stash_get_data(undoStorage,
486 suffix, suffix_len);
487 retval =
488 set_netSnmpHostAddressType(ci->data_context,
489 ui->ptr, ui->len);
490 if (retval) {
491 netsnmp_set_request_error(reqinfo, request,
492 SNMP_ERR_UNDOFAILED);
493 }
494 }
495 break;
496 case COLUMN_NETSNMPHOSTADDRESS:
497 {
498 int retval;
499 struct undoInfo *ui;
500 ui = netsnmp_oid_stash_get_data(undoStorage,
501 suffix, suffix_len);
502 retval =
503 set_netSnmpHostAddress(ci->data_context, ui->ptr,
504 ui->len);
505 if (retval) {
506 netsnmp_set_request_error(reqinfo, request,
507 SNMP_ERR_UNDOFAILED);
508 }
509 }
510 break;
511 case COLUMN_NETSNMPHOSTSTORAGE:
512 {
513 int retval;
514 struct undoInfo *ui;
515 ui = netsnmp_oid_stash_get_data(undoStorage,
516 suffix, suffix_len);
517 retval =
518 set_netSnmpHostStorage(ci->data_context, ui->ptr,
519 ui->len);
520 if (retval) {
521 netsnmp_set_request_error(reqinfo, request,
522 SNMP_ERR_UNDOFAILED);
523 }
524 }
525 break;
526 case COLUMN_NETSNMPHOSTROWSTATUS:
527 {
528 int retval;
529 struct undoInfo *ui;
530 ui = netsnmp_oid_stash_get_data(undoStorage,
531 suffix, suffix_len);
532 retval =
533 set_netSnmpHostRowStatus(ci->data_context, ui->ptr,
534 ui->len);
535 if (retval) {
536 netsnmp_set_request_error(reqinfo, request,
537 SNMP_ERR_UNDOFAILED);
538 }
539 }
540 break;
541 }
542 break;
543
544 case MODE_SET_FREE:
545 break;
546
547 default:
548 snmp_log(LOG_ERR,
549 "problem encountered in netSnmpHostsTable_handler: unsupported mode\n");
550 }
551 }
552
553 /** clean up after all requset processing has ended */
554 switch (reqinfo->mode) {
555 case MODE_SET_UNDO:
556 case MODE_SET_FREE:
557 case MODE_SET_COMMIT:
558 /** clear out the undo cache */
559 netsnmp_oid_stash_free(&undoStorage,
560 netSnmpHostsTable_free_undoInfo);
561 netsnmp_oid_stash_free(&commitStorage, netsnmp_oid_stash_no_free);
562 }
563
564
565 return SNMP_ERR_NOERROR;
566 }