Debian Codegraph @

agent/mibgroup/snmp-usm-dh-objects-mib/usmDHUserKeyTable/usmDHUserKeyTable_interface.c

raw
1 /*
2 * Note: this file originally auto-generated by mib2c using
3 * version : 1.67 $ of : mfd-interface.m2c,v $
4 *
5 * $Id$
6 */
7 /*
8 * *********************************************************************
9 * *********************************************************************
10 * *********************************************************************
11 * *** ***
12 * *** NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE ***
13 * *** ***
14 * *** ***
15 * *** THIS FILE DOES NOT CONTAIN ANY USER EDITABLE CODE. ***
16 * *** ***
17 * *** ***
18 * *** THE GENERATED CODE IS INTERNAL IMPLEMENTATION, AND ***
19 * *** ***
20 * *** ***
21 * *** IS SUBJECT TO CHANGE WITHOUT WARNING IN FUTURE RELEASES. ***
22 * *** ***
23 * *** ***
24 * *********************************************************************
25 * *********************************************************************
26 * *********************************************************************
27 */
28
29 /*
30 * standard Net-SNMP includes
31 */
32 #include <net-snmp/net-snmp-config.h>
33 #include <net-snmp/net-snmp-features.h>
34 #include <net-snmp/net-snmp-includes.h>
35 #include <net-snmp/agent/net-snmp-agent-includes.h>
36
37 /*
38 * include our parent header
39 */
40 #include "usmDHUserKeyTable.h"
41
42
43 #include <net-snmp/agent/table_container.h>
44 #include <net-snmp/library/container.h>
45
46 #include "usmDHUserKeyTable_interface.h"
47
48 #include <ctype.h>
49
50 netsnmp_feature_require(row_merge);
51 netsnmp_feature_require(baby_steps);
52 netsnmp_feature_require(check_all_requests_error);
53
54 /**********************************************************************
55 **********************************************************************
56 ***
57 *** Table usmDHUserKeyTable
58 ***
59 **********************************************************************
60 **********************************************************************/
61 /*
62 * SNMP-USM-DH-OBJECTS-MIB::usmDHUserKeyTable is subid 2 of usmDHPublicObjects.
63 * Its status is Current.
64 * OID: .1.3.6.1.3.101.1.1.2, length: 9
65 */
66 typedef struct usmDHUserKeyTable_interface_ctx_s {
67
68 netsnmp_container *container;
69 netsnmp_cache *cache;
70
71 usmDHUserKeyTable_registration *user_ctx;
72
73 netsnmp_table_registration_info tbl_info;
74
75 netsnmp_baby_steps_access_methods access_multiplexer;
76
77 u_int table_dirty;
78
79 } usmDHUserKeyTable_interface_ctx;
80
81 static usmDHUserKeyTable_interface_ctx usmDHUserKeyTable_if_ctx;
82
83 static void
84 _usmDHUserKeyTable_container_init(usmDHUserKeyTable_interface_ctx *
85 if_ctx);
86 static void
87 _usmDHUserKeyTable_container_shutdown(usmDHUserKeyTable_interface_ctx *
88 if_ctx);
89
90
91 netsnmp_container *
92 usmDHUserKeyTable_container_get(void)
93 {
94 return usmDHUserKeyTable_if_ctx.container;
95 }
96
97 usmDHUserKeyTable_registration *
98 usmDHUserKeyTable_registration_get(void)
99 {
100 return usmDHUserKeyTable_if_ctx.user_ctx;
101 }
102
103 usmDHUserKeyTable_registration *
104 usmDHUserKeyTable_registration_set(usmDHUserKeyTable_registration * newreg)
105 {
106 usmDHUserKeyTable_registration *old =
107 usmDHUserKeyTable_if_ctx.user_ctx;
108 usmDHUserKeyTable_if_ctx.user_ctx = newreg;
109 return old;
110 }
111
112 int
113 usmDHUserKeyTable_container_size(void)
114 {
115 return CONTAINER_SIZE(usmDHUserKeyTable_if_ctx.container);
116 }
117
118 u_int
119 usmDHUserKeyTable_dirty_get(void)
120 {
121 return usmDHUserKeyTable_if_ctx.table_dirty;
122 }
123
124 void
125 usmDHUserKeyTable_dirty_set(u_int status)
126 {
127 DEBUGMSGTL(("usmDHUserKeyTable:usmDHUserKeyTable_dirty_set",
128 "called. was %d, now %d\n",
129 usmDHUserKeyTable_if_ctx.table_dirty, status));
130 usmDHUserKeyTable_if_ctx.table_dirty = status;
131 }
132
133 /*
134 * mfd multiplexer modes
135 */
136 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_pre_request;
137 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_post_request;
138 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_object_lookup;
139 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_get_values;
140 #ifndef NETSNMP_DISABLE_SET_SUPPORT
141 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_check_objects;
142 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_undo_setup;
143 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_set_values;
144 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_undo_cleanup;
145 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_undo_values;
146 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_commit;
147 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_irreversible_commit;
148 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_undo_commit;
149 static Netsnmp_Node_Handler _mfd_usmDHUserKeyTable_check_dependencies;
150
151 NETSNMP_STATIC_INLINE int
152 _usmDHUserKeyTable_undo_column(usmDHUserKeyTable_rowreq_ctx * rowreq_ctx,
153 netsnmp_variable_list * var,
154 int column);
155 #endif
156
157 /**
158 * @internal
159 * Initialize the table usmDHUserKeyTable
160 * (Define its contents and how it's structured)
161 */
162 void
163 _usmDHUserKeyTable_initialize_interface(usmDHUserKeyTable_registration *
164 reg_ptr, u_long flags)
165 {
166 netsnmp_baby_steps_access_methods *access_multiplexer =
167 &usmDHUserKeyTable_if_ctx.access_multiplexer;
168 netsnmp_table_registration_info *tbl_info =
169 &usmDHUserKeyTable_if_ctx.tbl_info;
170 netsnmp_handler_registration *reginfo;
171 netsnmp_mib_handler *handler;
172 int mfd_modes = 0;
173
174 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_initialize_interface", "called\n"));
175
176
177 /*************************************************
178 *
179 * save interface context for usmDHUserKeyTable
180 */
181 /*
182 * Setting up the table's definition
183 */
184 netsnmp_table_helper_add_indexes(tbl_info, ASN_OCTET_STR,
185 /** index: usmUserEngineID */
186 ASN_OCTET_STR,
187 /** index: usmUserName */
188 0);
189
190 /*
191 * Define the minimum and maximum accessible columns. This
192 * optimizes retrieval.
193 */
194 tbl_info->min_column = USMDHUSERKEYTABLE_MIN_COL;
195 tbl_info->max_column = USMDHUSERKEYTABLE_MAX_COL;
196
197 /*
198 * save users context
199 */
200 usmDHUserKeyTable_if_ctx.user_ctx = reg_ptr;
201
202 /*
203 * call data access initialization code
204 */
205 usmDHUserKeyTable_init_data(reg_ptr);
206
207 /*
208 * set up the container
209 */
210 _usmDHUserKeyTable_container_init(&usmDHUserKeyTable_if_ctx);
211 if (NULL == usmDHUserKeyTable_if_ctx.container) {
212 snmp_log(LOG_ERR,
213 "could not initialize container for usmDHUserKeyTable\n");
214 return;
215 }
216
217 /*
218 * access_multiplexer: REQUIRED wrapper for get request handling
219 */
220 access_multiplexer->object_lookup =
221 _mfd_usmDHUserKeyTable_object_lookup;
222 access_multiplexer->get_values = _mfd_usmDHUserKeyTable_get_values;
223
224 /*
225 * no wrappers yet
226 */
227 access_multiplexer->pre_request = _mfd_usmDHUserKeyTable_pre_request;
228 access_multiplexer->post_request = _mfd_usmDHUserKeyTable_post_request;
229
230
231 #ifndef NETSNMP_DISABLE_SET_SUPPORT
232 /*
233 * REQUIRED wrappers for set request handling
234 */
235 access_multiplexer->object_syntax_checks =
236 _mfd_usmDHUserKeyTable_check_objects;
237 access_multiplexer->undo_setup = _mfd_usmDHUserKeyTable_undo_setup;
238 access_multiplexer->undo_cleanup = _mfd_usmDHUserKeyTable_undo_cleanup;
239 access_multiplexer->set_values = _mfd_usmDHUserKeyTable_set_values;
240 access_multiplexer->undo_sets = _mfd_usmDHUserKeyTable_undo_values;
241
242 /*
243 * no wrappers yet
244 */
245 access_multiplexer->commit = _mfd_usmDHUserKeyTable_commit;
246 access_multiplexer->undo_commit = _mfd_usmDHUserKeyTable_undo_commit;
247 access_multiplexer->irreversible_commit =
248 _mfd_usmDHUserKeyTable_irreversible_commit;
249
250 /*
251 * REQUIRED for tables with dependencies
252 */
253 access_multiplexer->consistency_checks =
254 _mfd_usmDHUserKeyTable_check_dependencies;
255 #endif
256
257 /*************************************************
258 *
259 * Create a registration, save our reg data, register table.
260 */
261 DEBUGMSGTL(("usmDHUserKeyTable:init_usmDHUserKeyTable",
262 "Registering usmDHUserKeyTable as a mibs-for-dummies table.\n"));
263 handler =
264 netsnmp_baby_steps_access_multiplexer_get(access_multiplexer);
265 reginfo =
266 netsnmp_handler_registration_create("usmDHUserKeyTable", handler,
267 usmDHUserKeyTable_oid,
268 usmDHUserKeyTable_oid_size,
269 HANDLER_CAN_BABY_STEP |
270 #ifndef NETSNMP_DISABLE_SET_SUPPORT
271 HANDLER_CAN_RWRITE
272 #else
273 HANDLER_CAN_RONLY
274 #endif /* NETSNMP_DISABLE_SET_SUPPORT */
275 );
276 if (NULL == reginfo) {
277 snmp_log(LOG_ERR, "error registering table usmDHUserKeyTable\n");
278 return;
279 }
280 reginfo->my_reg_void = &usmDHUserKeyTable_if_ctx;
281
282 /*************************************************
283 *
284 * set up baby steps handler, create it and inject it
285 */
286 if (access_multiplexer->object_lookup)
287 mfd_modes |= BABY_STEP_OBJECT_LOOKUP;
288 if (access_multiplexer->pre_request)
289 mfd_modes |= BABY_STEP_PRE_REQUEST;
290 if (access_multiplexer->post_request)
291 mfd_modes |= BABY_STEP_POST_REQUEST;
292
293 #ifndef NETSNMP_DISABLE_SET_SUPPORT
294 if (access_multiplexer->set_values)
295 mfd_modes |= BABY_STEP_SET_VALUES;
296 if (access_multiplexer->irreversible_commit)
297 mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT;
298 if (access_multiplexer->object_syntax_checks)
299 mfd_modes |= BABY_STEP_CHECK_OBJECT;
300
301 if (access_multiplexer->undo_setup)
302 mfd_modes |= BABY_STEP_UNDO_SETUP;
303 if (access_multiplexer->undo_cleanup)
304 mfd_modes |= BABY_STEP_UNDO_CLEANUP;
305 if (access_multiplexer->undo_sets)
306 mfd_modes |= BABY_STEP_UNDO_SETS;
307
308 if (access_multiplexer->row_creation)
309 mfd_modes |= BABY_STEP_ROW_CREATE;
310 if (access_multiplexer->consistency_checks)
311 mfd_modes |= BABY_STEP_CHECK_CONSISTENCY;
312 if (access_multiplexer->commit)
313 mfd_modes |= BABY_STEP_COMMIT;
314 if (access_multiplexer->undo_commit)
315 mfd_modes |= BABY_STEP_UNDO_COMMIT;
316 #endif
317
318 handler = netsnmp_baby_steps_handler_get(mfd_modes);
319 netsnmp_inject_handler(reginfo, handler);
320
321 /*************************************************
322 *
323 * inject row_merge helper with prefix rootoid_len + 2 (entry.col)
324 */
325 handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2);
326 netsnmp_inject_handler(reginfo, handler);
327
328 /*************************************************
329 *
330 * inject container_table helper
331 */
332 handler =
333 netsnmp_container_table_handler_get(tbl_info,
334 usmDHUserKeyTable_if_ctx.
335 container,
336 TABLE_CONTAINER_KEY_NETSNMP_INDEX);
337 netsnmp_inject_handler(reginfo, handler);
338
339 /*************************************************
340 *
341 * inject cache helper
342 */
343 if (NULL != usmDHUserKeyTable_if_ctx.cache) {
344 handler =
345 netsnmp_cache_handler_get(usmDHUserKeyTable_if_ctx.cache);
346 netsnmp_inject_handler(reginfo, handler);
347 }
348
349 /*
350 * register table
351 */
352 netsnmp_register_table(reginfo, tbl_info);
353
354 } /* _usmDHUserKeyTable_initialize_interface */
355
356 /**
357 * @internal
358 * Shutdown the table usmDHUserKeyTable
359 */
360 void
361 _usmDHUserKeyTable_shutdown_interface(usmDHUserKeyTable_registration *
362 reg_ptr)
363 {
364 /*
365 * shutdown the container
366 */
367 _usmDHUserKeyTable_container_shutdown(&usmDHUserKeyTable_if_ctx);
368 }
369
370 void
371 usmDHUserKeyTable_valid_columns_set(netsnmp_column_info *vc)
372 {
373 usmDHUserKeyTable_if_ctx.tbl_info.valid_columns = vc;
374 } /* usmDHUserKeyTable_valid_columns_set */
375
376 /**
377 * @internal
378 * convert the index component stored in the context to an oid
379 */
380 int
381 usmDHUserKeyTable_index_to_oid(netsnmp_index * oid_idx,
382 usmDHUserKeyTable_mib_index * mib_idx)
383 {
384 int err = SNMP_ERR_NOERROR;
385
386 /*
387 * temp storage for parsing indexes
388 */
389 /*
390 * usmUserEngineID(1)/SnmpEngineID/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h
391 */
392 netsnmp_variable_list var_usmUserEngineID;
393 /*
394 * usmUserName(2)/SnmpAdminString/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/H
395 */
396 netsnmp_variable_list var_usmUserName;
397
398 /*
399 * set up varbinds
400 */
401 memset(&var_usmUserEngineID, 0x00, sizeof(var_usmUserEngineID));
402 var_usmUserEngineID.type = ASN_OCTET_STR;
403 memset(&var_usmUserName, 0x00, sizeof(var_usmUserName));
404 var_usmUserName.type = ASN_OCTET_STR;
405
406 /*
407 * chain temp index varbinds together
408 */
409 var_usmUserEngineID.next_variable = &var_usmUserName;
410 var_usmUserName.next_variable = NULL;
411
412
413 DEBUGMSGTL(("verbose:usmDHUserKeyTable:usmDHUserKeyTable_index_to_oid",
414 "called\n"));
415
416 /*
417 * usmUserEngineID(1)/SnmpEngineID/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h
418 */
419 snmp_set_var_value(&var_usmUserEngineID,
420 (u_char *) & mib_idx->usmUserEngineID,
421 mib_idx->usmUserEngineID_len *
422 sizeof(mib_idx->usmUserEngineID[0]));
423
424 /*
425 * usmUserName(2)/SnmpAdminString/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/H
426 */
427 snmp_set_var_value(&var_usmUserName, (u_char *) & mib_idx->usmUserName,
428 mib_idx->usmUserName_len *
429 sizeof(mib_idx->usmUserName[0]));
430
431
432 err = build_oid_noalloc(oid_idx->oids, oid_idx->len, &oid_idx->len,
433 NULL, 0, &var_usmUserEngineID);
434 if (err)
435 snmp_log(LOG_ERR, "error %d converting index to oid\n", err);
436
437 /*
438 * parsing may have allocated memory. free it.
439 */
440 snmp_reset_var_buffers(&var_usmUserEngineID);
441
442 return err;
443 } /* usmDHUserKeyTable_index_to_oid */
444
445 /**
446 * extract usmDHUserKeyTable indexes from a netsnmp_index
447 *
448 * @retval SNMP_ERR_NOERROR : no error
449 * @retval SNMP_ERR_GENERR : error
450 */
451 int
452 usmDHUserKeyTable_index_from_oid(netsnmp_index * oid_idx,
453 usmDHUserKeyTable_mib_index * mib_idx)
454 {
455 int err = SNMP_ERR_NOERROR;
456
457 /*
458 * temp storage for parsing indexes
459 */
460 /*
461 * usmUserEngineID(1)/SnmpEngineID/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h
462 */
463 netsnmp_variable_list var_usmUserEngineID;
464 /*
465 * usmUserName(2)/SnmpAdminString/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/H
466 */
467 netsnmp_variable_list var_usmUserName;
468
469 /*
470 * set up varbinds
471 */
472 memset(&var_usmUserEngineID, 0x00, sizeof(var_usmUserEngineID));
473 var_usmUserEngineID.type = ASN_OCTET_STR;
474 memset(&var_usmUserName, 0x00, sizeof(var_usmUserName));
475 var_usmUserName.type = ASN_OCTET_STR;
476
477 /*
478 * chain temp index varbinds together
479 */
480 var_usmUserEngineID.next_variable = &var_usmUserName;
481 var_usmUserName.next_variable = NULL;
482
483
484 DEBUGMSGTL(("verbose:usmDHUserKeyTable:usmDHUserKeyTable_index_from_oid", "called\n"));
485
486 /*
487 * parse the oid into the individual index components
488 */
489 err = parse_oid_indexes(oid_idx->oids, oid_idx->len,
490 &var_usmUserEngineID);
491 if (err == SNMP_ERR_NOERROR) {
492 /*
493 * copy out values
494 */
495 /*
496 * NOTE: val_len is in bytes, usmUserEngineID_len might not be
497 */
498 if (var_usmUserEngineID.val_len > sizeof(mib_idx->usmUserEngineID))
499 err = SNMP_ERR_GENERR;
500 else {
501 memcpy(mib_idx->usmUserEngineID,
502 var_usmUserEngineID.val.string,
503 var_usmUserEngineID.val_len);
504 mib_idx->usmUserEngineID_len =
505 var_usmUserEngineID.val_len /
506 sizeof(mib_idx->usmUserEngineID[0]);
507 }
508 /*
509 * NOTE: val_len is in bytes, usmUserName_len might not be
510 */
511 if (var_usmUserName.val_len > sizeof(mib_idx->usmUserName))
512 err = SNMP_ERR_GENERR;
513 else {
514 memcpy(mib_idx->usmUserName, var_usmUserName.val.string,
515 var_usmUserName.val_len);
516 mib_idx->usmUserName_len =
517 var_usmUserName.val_len / sizeof(mib_idx->usmUserName[0]);
518 }
519
520
521 }
522
523 /*
524 * parsing may have allocated memory. free it.
525 */
526 snmp_reset_var_buffers(&var_usmUserEngineID);
527
528 return err;
529 } /* usmDHUserKeyTable_index_from_oid */
530
531
532 /*
533 *********************************************************************
534 * @internal
535 * allocate resources for a usmDHUserKeyTable_rowreq_ctx
536 */
537 usmDHUserKeyTable_rowreq_ctx *
538 usmDHUserKeyTable_allocate_rowreq_ctx(usmDHUserKeyTable_data * data,
539 void *user_init_ctx)
540 {
541 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
542 SNMP_MALLOC_TYPEDEF(usmDHUserKeyTable_rowreq_ctx);
543
544 DEBUGMSGTL(("internal:usmDHUserKeyTable:usmDHUserKeyTable_allocate_rowreq_ctx", "called\n"));
545
546 if (NULL == rowreq_ctx) {
547 snmp_log(LOG_ERR, "Couldn't allocate memory for a "
548 "usmDHUserKeyTable_rowreq_ctx.\n");
549 return NULL;
550 } else {
551 if (NULL != data) {
552 /*
553 * track if we got data from user
554 */
555 rowreq_ctx->rowreq_flags |= MFD_ROW_DATA_FROM_USER;
556 rowreq_ctx->data = data;
557 } else if (NULL ==
558 (rowreq_ctx->data =
559 usmDHUserKeyTable_allocate_data())) {
560 SNMP_FREE(rowreq_ctx);
561 return NULL;
562 }
563 }
564
565 /*
566 * undo context will be allocated when needed (in *_undo_setup)
567 */
568
569 rowreq_ctx->oid_idx.oids = rowreq_ctx->oid_tmp;
570
571 rowreq_ctx->usmDHUserKeyTable_data_list = NULL;
572
573 /*
574 * if we allocated data, call init routine
575 */
576 if (!(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER)) {
577 if (SNMPERR_SUCCESS !=
578 usmDHUserKeyTable_rowreq_ctx_init(rowreq_ctx, user_init_ctx)) {
579 usmDHUserKeyTable_release_rowreq_ctx(rowreq_ctx);
580 rowreq_ctx = NULL;
581 }
582 }
583
584 return rowreq_ctx;
585 } /* usmDHUserKeyTable_allocate_rowreq_ctx */
586
587 /*
588 * @internal
589 * release resources for a usmDHUserKeyTable_rowreq_ctx
590 */
591 void
592 usmDHUserKeyTable_release_rowreq_ctx(usmDHUserKeyTable_rowreq_ctx *
593 rowreq_ctx)
594 {
595 DEBUGMSGTL(("internal:usmDHUserKeyTable:usmDHUserKeyTable_release_rowreq_ctx", "called\n"));
596
597 netsnmp_assert(NULL != rowreq_ctx);
598
599 usmDHUserKeyTable_rowreq_ctx_cleanup(rowreq_ctx);
600
601 /*
602 * for non-transient data, don't free data we got from the user
603 */
604 if ((rowreq_ctx->data) &&
605 !(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER))
606 usmDHUserKeyTable_release_data(rowreq_ctx->data);
607
608 if (rowreq_ctx->undo) {
609 usmDHUserKeyTable_release_data(rowreq_ctx->undo);
610 rowreq_ctx->undo = NULL;
611 }
612
613 /*
614 * free index oid pointer
615 */
616 if (rowreq_ctx->oid_idx.oids != rowreq_ctx->oid_tmp)
617 free(rowreq_ctx->oid_idx.oids);
618
619 SNMP_FREE(rowreq_ctx);
620 } /* usmDHUserKeyTable_release_rowreq_ctx */
621
622 /**
623 * @internal
624 * wrapper
625 */
626 static int
627 _mfd_usmDHUserKeyTable_pre_request(netsnmp_mib_handler *handler,
628 netsnmp_handler_registration *reginfo,
629 netsnmp_agent_request_info *agtreq_info,
630 netsnmp_request_info *requests)
631 {
632 int rc;
633
634 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_pre_request", "called\n"));
635
636 if (1 != netsnmp_row_merge_status_first(reginfo, agtreq_info)) {
637 DEBUGMSGTL(("internal:usmDHUserKeyTable",
638 "skipping additional pre_request\n"));
639 return SNMP_ERR_NOERROR;
640 }
641
642 rc = usmDHUserKeyTable_pre_request(usmDHUserKeyTable_if_ctx.user_ctx);
643 if (MFD_SUCCESS != rc) {
644 /*
645 * nothing we can do about it but log it
646 */
647 DEBUGMSGTL(("usmDHUserKeyTable", "error %d from "
648 "usmDHUserKeyTable_pre_request\n", rc));
649 netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
650 }
651
652 return SNMP_ERR_NOERROR;
653 } /* _mfd_usmDHUserKeyTable_pre_request */
654
655 /**
656 * @internal
657 * wrapper
658 */
659 static int
660 _mfd_usmDHUserKeyTable_post_request(netsnmp_mib_handler *handler,
661 netsnmp_handler_registration *reginfo,
662 netsnmp_agent_request_info
663 *agtreq_info,
664 netsnmp_request_info *requests)
665 {
666 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
667 netsnmp_container_table_row_extract(requests);
668 int rc, packet_rc;
669
670 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_post_request", "called\n"));
671
672 /*
673 * release row context, if deleted
674 */
675 if (rowreq_ctx && (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED))
676 usmDHUserKeyTable_release_rowreq_ctx(rowreq_ctx);
677
678 /*
679 * wait for last call before calling user
680 */
681 if (1 != netsnmp_row_merge_status_last(reginfo, agtreq_info)) {
682 DEBUGMSGTL(("internal:usmDHUserKeyTable",
683 "waiting for last post_request\n"));
684 return SNMP_ERR_NOERROR;
685 }
686
687 packet_rc = netsnmp_check_all_requests_error(agtreq_info->asp, 0);
688 if ((MFD_SUCCESS != packet_rc) && usmDHUserKeyTable_dirty_get()) {
689 /*
690 * we shouldn't get here. the undo steps should also clear
691 * the dirty flags.
692 */
693 snmp_log(LOG_WARNING,
694 "usmDHUserKeyTable dirty flag set in post_request "
695 "but status != SUCCESS.\n");
696 }
697
698 rc = usmDHUserKeyTable_post_request(usmDHUserKeyTable_if_ctx.user_ctx,
699 packet_rc);
700 if (MFD_SUCCESS != rc) {
701 /*
702 * nothing we can do about it but log it
703 */
704 DEBUGMSGTL(("usmDHUserKeyTable", "error %d from "
705 "usmDHUserKeyTable_post_request\n", rc));
706 }
707
708 return SNMP_ERR_NOERROR;
709 } /* _mfd_usmDHUserKeyTable_post_request */
710
711 /**
712 * @internal
713 * wrapper
714 */
715 static int
716 _mfd_usmDHUserKeyTable_object_lookup(netsnmp_mib_handler *handler,
717 netsnmp_handler_registration *reginfo,
718 netsnmp_agent_request_info
719 *agtreq_info,
720 netsnmp_request_info *requests)
721 {
722 int rc = SNMP_ERR_NOERROR;
723 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
724 netsnmp_container_table_row_extract(requests);
725
726 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_object_lookup", "called\n"));
727
728 /*
729 * get our context from mfd
730 * usmDHUserKeyTable_interface_ctx *if_ctx =
731 * (usmDHUserKeyTable_interface_ctx *)reginfo->my_reg_void;
732 */
733
734 if (NULL == rowreq_ctx) {
735 rc = SNMP_ERR_NOCREATION;
736 }
737
738 if (MFD_SUCCESS != rc)
739 netsnmp_request_set_error_all(requests, rc);
740 else
741 usmDHUserKeyTable_row_prep(rowreq_ctx);
742
743 return SNMP_VALIDATE_ERR(rc);
744 } /* _mfd_usmDHUserKeyTable_object_lookup */
745
746 /***********************************************************************
747 *
748 * GET processing
749 *
750 ***********************************************************************/
751 /*
752 * @internal
753 * Retrieve the value for a particular column
754 */
755 NETSNMP_STATIC_INLINE int
756 _usmDHUserKeyTable_get_column(usmDHUserKeyTable_rowreq_ctx * rowreq_ctx,
757 netsnmp_variable_list * var, int column)
758 {
759 int rc = SNMPERR_SUCCESS;
760
761 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_get_column", "called for %d\n", column));
762
763
764 netsnmp_assert(NULL != rowreq_ctx);
765
766 switch (column) {
767
768 /*
769 * usmDHUserAuthKeyChange(1)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
770 */
771 case COLUMN_USMDHUSERAUTHKEYCHANGE:
772 var->type = ASN_OCTET_STR;
773 rc = usmDHUserAuthKeyChange_get(rowreq_ctx,
774 &var->val.string,
775 &var->val_len);
776 break;
777
778 /*
779 * usmDHUserOwnAuthKeyChange(2)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
780 */
781 case COLUMN_USMDHUSEROWNAUTHKEYCHANGE:
782 var->type = ASN_OCTET_STR;
783 rc = usmDHUserOwnAuthKeyChange_get(rowreq_ctx,
784 &var->val.string,
785 &var->val_len);
786 break;
787
788 /*
789 * usmDHUserPrivKeyChange(3)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
790 */
791 case COLUMN_USMDHUSERPRIVKEYCHANGE:
792 var->type = ASN_OCTET_STR;
793 rc = usmDHUserPrivKeyChange_get(rowreq_ctx,
794 &var->val.string,
795 &var->val_len);
796 break;
797
798 /*
799 * usmDHUserOwnPrivKeyChange(4)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
800 */
801 case COLUMN_USMDHUSEROWNPRIVKEYCHANGE:
802 var->type = ASN_OCTET_STR;
803 rc = usmDHUserOwnPrivKeyChange_get(rowreq_ctx,
804 &var->val.string,
805 &var->val_len);
806 break;
807
808 default:
809 snmp_log(LOG_ERR,
810 "unknown column %d in _usmDHUserKeyTable_get_column\n",
811 column);
812 break;
813 }
814
815 return rc;
816 } /* _usmDHUserKeyTable_get_column */
817
818 int
819 _mfd_usmDHUserKeyTable_get_values(netsnmp_mib_handler *handler,
820 netsnmp_handler_registration *reginfo,
821 netsnmp_agent_request_info *agtreq_info,
822 netsnmp_request_info *requests)
823 {
824 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
825 netsnmp_container_table_row_extract(requests);
826 netsnmp_table_request_info *tri;
827 u_char *old_string;
828 void (*dataFreeHook) (void *);
829 int rc;
830
831 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_get_values", "called\n"));
832
833 netsnmp_assert(NULL != rowreq_ctx);
834
835 for (; requests; requests = requests->next) {
836 /*
837 * save old pointer, so we can free it if replaced
838 */
839 old_string = requests->requestvb->val.string;
840 dataFreeHook = requests->requestvb->dataFreeHook;
841 if (NULL == requests->requestvb->val.string) {
842 requests->requestvb->val.string = requests->requestvb->buf;
843 requests->requestvb->val_len =
844 sizeof(requests->requestvb->buf);
845 } else if (requests->requestvb->buf ==
846 requests->requestvb->val.string) {
847 if (requests->requestvb->val_len !=
848 sizeof(requests->requestvb->buf))
849 requests->requestvb->val_len =
850 sizeof(requests->requestvb->buf);
851 }
852
853 /*
854 * get column data
855 */
856 tri = netsnmp_extract_table_info(requests);
857 if (NULL == tri)
858 continue;
859
860 rc = _usmDHUserKeyTable_get_column(rowreq_ctx, requests->requestvb,
861 tri->colnum);
862 if (rc) {
863 if (MFD_SKIP == rc) {
864 requests->requestvb->type = SNMP_NOSUCHINSTANCE;
865 rc = SNMP_ERR_NOERROR;
866 }
867 } else if (NULL == requests->requestvb->val.string) {
868 snmp_log(LOG_ERR, "NULL varbind data pointer!\n");
869 rc = SNMP_ERR_GENERR;
870 }
871 if (rc)
872 netsnmp_request_set_error(requests, SNMP_VALIDATE_ERR(rc));
873
874 /*
875 * if the buffer wasn't used previously for the old data (i.e. it
876 * was allocated memory) and the get routine replaced the pointer,
877 * we need to free the previous pointer.
878 */
879 if (old_string && (old_string != requests->requestvb->buf) &&
880 (requests->requestvb->val.string != old_string)) {
881 if (dataFreeHook)
882 (*dataFreeHook) (old_string);
883 else
884 free(old_string);
885 }
886 } /* for results */
887
888 return SNMP_ERR_NOERROR;
889 } /* _mfd_usmDHUserKeyTable_get_values */
890
891
892 #ifndef NETSNMP_DISABLE_SET_SUPPORT
893 /***********************************************************************
894 *
895 * SET processing
896 *
897 ***********************************************************************/
898
899 /*----------------------------------------------------------------------
900 *
901 * SET: Syntax checks
902 *
903 *---------------------------------------------------------------------*/
904 /*
905 * @internal
906 * Check the syntax for a particular column
907 */
908 NETSNMP_STATIC_INLINE int
909 _usmDHUserKeyTable_check_column(usmDHUserKeyTable_rowreq_ctx * rowreq_ctx,
910 netsnmp_variable_list * var, int column)
911 {
912 int rc = SNMPERR_SUCCESS;
913
914 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_check_column", "called for %d\n", column));
915
916 netsnmp_assert(NULL != rowreq_ctx);
917
918 switch (column) {
919
920 /*
921 * usmDHUserAuthKeyChange(1)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
922 */
923 case COLUMN_USMDHUSERAUTHKEYCHANGE:
924 rc = netsnmp_check_vb_type(var, ASN_OCTET_STR);
925 if (SNMPERR_SUCCESS != rc) {
926 DEBUGMSGTL(("usmDHUserKeyTable:_usmDHUserKeyTable_check_column:usmDHUserAuthKeyChange", "varbind validation failed (eg bad type or size)\n"));
927 } else {
928 rc = usmDHUserAuthKeyChange_check_value(rowreq_ctx,
929 var->val.
930 string, var->val_len);
931 if ((MFD_SUCCESS != rc) && (MFD_NOT_VALID_EVER != rc)
932 && (MFD_NOT_VALID_NOW != rc)) {
933 snmp_log(LOG_ERR,
934 "bad rc %d from usmDHUserAuthKeyChange_check_value\n",
935 rc);
936 rc = SNMP_ERR_GENERR;
937 }
938 }
939 break;
940
941 /*
942 * usmDHUserOwnAuthKeyChange(2)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
943 */
944 case COLUMN_USMDHUSEROWNAUTHKEYCHANGE:
945 rc = netsnmp_check_vb_type(var, ASN_OCTET_STR);
946 if (SNMPERR_SUCCESS != rc) {
947 DEBUGMSGTL(("usmDHUserKeyTable:_usmDHUserKeyTable_check_column:usmDHUserOwnAuthKeyChange", "varbind validation failed (eg bad type or size)\n"));
948 } else {
949 rc = usmDHUserOwnAuthKeyChange_check_value(rowreq_ctx,
950 var->val.
951 string,
952 var->val_len);
953 if ((MFD_SUCCESS != rc) && (MFD_NOT_VALID_EVER != rc)
954 && (MFD_NOT_VALID_NOW != rc)) {
955 snmp_log(LOG_ERR,
956 "bad rc %d from usmDHUserOwnAuthKeyChange_check_value\n",
957 rc);
958 rc = SNMP_ERR_GENERR;
959 }
960 }
961 break;
962
963 /*
964 * usmDHUserPrivKeyChange(3)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
965 */
966 case COLUMN_USMDHUSERPRIVKEYCHANGE:
967 rc = netsnmp_check_vb_type(var, ASN_OCTET_STR);
968 if (SNMPERR_SUCCESS != rc) {
969 DEBUGMSGTL(("usmDHUserKeyTable:_usmDHUserKeyTable_check_column:usmDHUserPrivKeyChange", "varbind validation failed (eg bad type or size)\n"));
970 } else {
971 rc = usmDHUserPrivKeyChange_check_value(rowreq_ctx,
972 var->val.
973 string, var->val_len);
974 if ((MFD_SUCCESS != rc) && (MFD_NOT_VALID_EVER != rc)
975 && (MFD_NOT_VALID_NOW != rc)) {
976 snmp_log(LOG_ERR,
977 "bad rc %d from usmDHUserPrivKeyChange_check_value\n",
978 rc);
979 rc = SNMP_ERR_GENERR;
980 }
981 }
982 break;
983
984 /*
985 * usmDHUserOwnPrivKeyChange(4)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
986 */
987 case COLUMN_USMDHUSEROWNPRIVKEYCHANGE:
988 rc = netsnmp_check_vb_type(var, ASN_OCTET_STR);
989 if (SNMPERR_SUCCESS != rc) {
990 DEBUGMSGTL(("usmDHUserKeyTable:_usmDHUserKeyTable_check_column:usmDHUserOwnPrivKeyChange", "varbind validation failed (eg bad type or size)\n"));
991 } else {
992 rc = usmDHUserOwnPrivKeyChange_check_value(rowreq_ctx,
993 var->val.
994 string,
995 var->val_len);
996 if ((MFD_SUCCESS != rc) && (MFD_NOT_VALID_EVER != rc)
997 && (MFD_NOT_VALID_NOW != rc)) {
998 snmp_log(LOG_ERR,
999 "bad rc %d from usmDHUserOwnPrivKeyChange_check_value\n",
1000 rc);
1001 rc = SNMP_ERR_GENERR;
1002 }
1003 }
1004 break;
1005
1006 default: /** We shouldn't get here */
1007 rc = SNMP_ERR_GENERR;
1008 snmp_log(LOG_ERR,
1009 "unknown column %d in _usmDHUserKeyTable_check_column\n",
1010 column);
1011 }
1012
1013 return rc;
1014 } /* _usmDHUserKeyTable_check_column */
1015
1016 int
1017 _mfd_usmDHUserKeyTable_check_objects(netsnmp_mib_handler *handler,
1018 netsnmp_handler_registration *reginfo,
1019 netsnmp_agent_request_info
1020 *agtreq_info,
1021 netsnmp_request_info *requests)
1022 {
1023 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1024 netsnmp_container_table_row_extract(requests);
1025 netsnmp_table_request_info *tri;
1026 int rc;
1027
1028 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_check_objects", "called\n"));
1029
1030 netsnmp_assert(NULL != rowreq_ctx);
1031
1032 for (; requests; requests = requests->next) {
1033
1034 /*
1035 * get column number from table request info, and check that column
1036 */
1037 tri = netsnmp_extract_table_info(requests);
1038 if (NULL == tri)
1039 continue;
1040
1041 rc = _usmDHUserKeyTable_check_column(rowreq_ctx,
1042 requests->requestvb,
1043 tri->colnum);
1044 if (rc) {
1045 netsnmp_request_set_error(requests, SNMP_VALIDATE_ERR(rc));
1046 break;
1047 }
1048
1049 } /* for results */
1050
1051 return SNMP_ERR_NOERROR;
1052 } /* _mfd_usmDHUserKeyTable_check_objects */
1053
1054
1055 /*----------------------------------------------------------------------
1056 *
1057 * SET: check dependencies
1058 *
1059 *---------------------------------------------------------------------*/
1060 /*
1061 * @internal
1062 * Check dependencies wrapper
1063 */
1064 static int
1065 _mfd_usmDHUserKeyTable_check_dependencies(netsnmp_mib_handler *handler, netsnmp_handler_registration
1066 *reginfo, netsnmp_agent_request_info
1067 *agtreq_info,
1068 netsnmp_request_info *requests)
1069 {
1070 int rc;
1071 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1072 netsnmp_container_table_row_extract(requests);
1073 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_check_dependencies", "called\n"));
1074
1075 netsnmp_assert(NULL != rowreq_ctx);
1076
1077 rc = usmDHUserKeyTable_check_dependencies(rowreq_ctx);
1078 if (rc) {
1079 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1080 "usmDHUserKeyTable_check_dependencies\n", rc));
1081 netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
1082 }
1083
1084 return SNMP_ERR_NOERROR;
1085 } /* _mfd_usmDHUserKeyTable_check_dependencies */
1086
1087 /*----------------------------------------------------------------------
1088 *
1089 * SET: Undo setup
1090 *
1091 *---------------------------------------------------------------------*/
1092 /*
1093 * @internal
1094 * Set the value for a particular column
1095 */
1096 NETSNMP_STATIC_INLINE int
1097 _usmDHUserKeyTable_undo_setup_column(usmDHUserKeyTable_rowreq_ctx *
1098 rowreq_ctx, int column)
1099 {
1100 int rc = SNMPERR_SUCCESS;
1101
1102 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_undo_setup_column", "called for %d\n", column));
1103
1104 netsnmp_assert(NULL != rowreq_ctx);
1105
1106 switch (column) {
1107
1108 /*
1109 * usmDHUserAuthKeyChange(1)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1110 */
1111 case COLUMN_USMDHUSERAUTHKEYCHANGE:
1112 rowreq_ctx->column_set_flags |= COLUMN_USMDHUSERAUTHKEYCHANGE_FLAG;
1113 rc = usmDHUserAuthKeyChange_undo_setup(rowreq_ctx);
1114 break;
1115
1116 /*
1117 * usmDHUserOwnAuthKeyChange(2)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1118 */
1119 case COLUMN_USMDHUSEROWNAUTHKEYCHANGE:
1120 rowreq_ctx->column_set_flags |=
1121 COLUMN_USMDHUSEROWNAUTHKEYCHANGE_FLAG;
1122 rc = usmDHUserOwnAuthKeyChange_undo_setup(rowreq_ctx);
1123 break;
1124
1125 /*
1126 * usmDHUserPrivKeyChange(3)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1127 */
1128 case COLUMN_USMDHUSERPRIVKEYCHANGE:
1129 rowreq_ctx->column_set_flags |= COLUMN_USMDHUSERPRIVKEYCHANGE_FLAG;
1130 rc = usmDHUserPrivKeyChange_undo_setup(rowreq_ctx);
1131 break;
1132
1133 /*
1134 * usmDHUserOwnPrivKeyChange(4)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1135 */
1136 case COLUMN_USMDHUSEROWNPRIVKEYCHANGE:
1137 rowreq_ctx->column_set_flags |=
1138 COLUMN_USMDHUSEROWNPRIVKEYCHANGE_FLAG;
1139 rc = usmDHUserOwnPrivKeyChange_undo_setup(rowreq_ctx);
1140 break;
1141
1142 default:
1143 snmp_log(LOG_ERR,
1144 "unknown column %d in _usmDHUserKeyTable_undo_setup_column\n",
1145 column);
1146 break;
1147 }
1148
1149 return rc;
1150 } /* _usmDHUserKeyTable_undo_setup_column */
1151
1152
1153 /**
1154 * @internal
1155 * undo setup
1156 */
1157 int
1158 _mfd_usmDHUserKeyTable_undo_setup(netsnmp_mib_handler *handler,
1159 netsnmp_handler_registration *reginfo,
1160 netsnmp_agent_request_info *agtreq_info,
1161 netsnmp_request_info *requests)
1162 {
1163 int rc;
1164 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1165 netsnmp_container_table_row_extract(requests);
1166
1167 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_undo_setup", "called\n"));
1168
1169 netsnmp_assert(NULL != rowreq_ctx);
1170
1171 /*
1172 * allocate undo context
1173 */
1174 rowreq_ctx->undo = usmDHUserKeyTable_allocate_data();
1175 if (NULL == rowreq_ctx->undo) {
1176 /** msg already logged */
1177 netsnmp_request_set_error_all(requests,
1178 SNMP_ERR_RESOURCEUNAVAILABLE);
1179 return SNMP_ERR_NOERROR;
1180 }
1181
1182 /*
1183 * row undo setup
1184 */
1185 rowreq_ctx->column_set_flags = 0;
1186 rc = usmDHUserKeyTable_undo_setup(rowreq_ctx);
1187 if (MFD_SUCCESS != rc) {
1188 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1189 "usmDHUserKeyTable_undo_setup\n", rc));
1190 netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
1191 } else {
1192 /*
1193 * column undo setup
1194 */
1195 netsnmp_table_request_info *tri;
1196 for (; requests; requests = requests->next) {
1197 /*
1198 * set column data
1199 */
1200 tri = netsnmp_extract_table_info(requests);
1201 if (NULL == tri)
1202 continue;
1203
1204 rc = _usmDHUserKeyTable_undo_setup_column(rowreq_ctx,
1205 tri->colnum);
1206 if (MFD_SUCCESS != rc) {
1207 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1208 "usmDHUserKeyTable_undo_setup_column\n", rc));
1209 netsnmp_set_request_error(agtreq_info, requests,
1210 SNMP_VALIDATE_ERR(rc));
1211 }
1212 } /* for results */
1213 }
1214
1215 return SNMP_ERR_NOERROR;
1216 } /* _mfd_usmDHUserKeyTable_undo_setup */
1217
1218 /**
1219 * @internal
1220 * undo setup
1221 */
1222 int
1223 _mfd_usmDHUserKeyTable_undo_cleanup(netsnmp_mib_handler *handler,
1224 netsnmp_handler_registration *reginfo,
1225 netsnmp_agent_request_info
1226 *agtreq_info,
1227 netsnmp_request_info *requests)
1228 {
1229 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1230 netsnmp_container_table_row_extract(requests);
1231 int rc;
1232
1233 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_undo_cleanup", "called\n"));
1234
1235 /*
1236 * failed row create in early stages has no rowreq_ctx
1237 */
1238 if (NULL == rowreq_ctx)
1239 return MFD_SUCCESS;
1240
1241 /*
1242 * call user cleanup
1243 */
1244 rc = usmDHUserKeyTable_undo_cleanup(rowreq_ctx);
1245 if (MFD_SUCCESS != rc) {
1246 /*
1247 * nothing we can do about it but log it
1248 */
1249 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1250 "usmDHUserKeyTable_undo_cleanup\n", rc));
1251 }
1252
1253 /*
1254 * release undo context, if needed
1255 */
1256 if (rowreq_ctx->undo) {
1257 usmDHUserKeyTable_release_data(rowreq_ctx->undo);
1258 rowreq_ctx->undo = NULL;
1259 }
1260
1261
1262 return SNMP_ERR_NOERROR;
1263 } /* _mfd_usmDHUserKeyTable_undo_cleanup */
1264
1265 /*----------------------------------------------------------------------
1266 *
1267 * SET: Set values
1268 *
1269 *---------------------------------------------------------------------*/
1270 /*
1271 * @internal
1272 * Set the value for a particular column
1273 */
1274 NETSNMP_STATIC_INLINE int
1275 _usmDHUserKeyTable_set_column(usmDHUserKeyTable_rowreq_ctx * rowreq_ctx,
1276 netsnmp_variable_list * var, int column)
1277 {
1278 int rc = SNMPERR_SUCCESS;
1279
1280 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_set_column",
1281 "called for %d\n", column));
1282
1283 netsnmp_assert(NULL != rowreq_ctx);
1284
1285 switch (column) {
1286
1287 /*
1288 * usmDHUserAuthKeyChange(1)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1289 */
1290 case COLUMN_USMDHUSERAUTHKEYCHANGE:
1291 rowreq_ctx->column_set_flags |= COLUMN_USMDHUSERAUTHKEYCHANGE_FLAG;
1292 rc = usmDHUserAuthKeyChange_set(rowreq_ctx,
1293 var->val.string,
1294 var->val_len);
1295 break;
1296
1297 /*
1298 * usmDHUserOwnAuthKeyChange(2)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1299 */
1300 case COLUMN_USMDHUSEROWNAUTHKEYCHANGE:
1301 rowreq_ctx->column_set_flags |=
1302 COLUMN_USMDHUSEROWNAUTHKEYCHANGE_FLAG;
1303 rc = usmDHUserOwnAuthKeyChange_set(rowreq_ctx,
1304 var->val.string,
1305 var->val_len);
1306 break;
1307
1308 /*
1309 * usmDHUserPrivKeyChange(3)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1310 */
1311 case COLUMN_USMDHUSERPRIVKEYCHANGE:
1312 rowreq_ctx->column_set_flags |= COLUMN_USMDHUSERPRIVKEYCHANGE_FLAG;
1313 rc = usmDHUserPrivKeyChange_set(rowreq_ctx,
1314 var->val.string,
1315 var->val_len);
1316 break;
1317
1318 /*
1319 * usmDHUserOwnPrivKeyChange(4)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1320 */
1321 case COLUMN_USMDHUSEROWNPRIVKEYCHANGE:
1322 rowreq_ctx->column_set_flags |=
1323 COLUMN_USMDHUSEROWNPRIVKEYCHANGE_FLAG;
1324 rc = usmDHUserOwnPrivKeyChange_set(rowreq_ctx,
1325 var->val.string,
1326 var->val_len);
1327 break;
1328
1329 default:
1330 snmp_log(LOG_ERR,
1331 "unknown column %d in _usmDHUserKeyTable_set_column\n",
1332 column);
1333 rc = SNMP_ERR_GENERR;
1334 break;
1335 }
1336
1337 return rc;
1338 } /* _usmDHUserKeyTable_set_column */
1339
1340 int
1341 _mfd_usmDHUserKeyTable_set_values(netsnmp_mib_handler *handler,
1342 netsnmp_handler_registration *reginfo,
1343 netsnmp_agent_request_info *agtreq_info,
1344 netsnmp_request_info *requests)
1345 {
1346 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1347 netsnmp_container_table_row_extract(requests);
1348 netsnmp_table_request_info *tri;
1349 int rc = SNMP_ERR_NOERROR;
1350
1351 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_set_values", "called\n"));
1352
1353 netsnmp_assert(NULL != rowreq_ctx);
1354
1355 rowreq_ctx->column_set_flags = 0;
1356 for (; requests; requests = requests->next) {
1357 /*
1358 * set column data
1359 */
1360 tri = netsnmp_extract_table_info(requests);
1361 if (NULL == tri)
1362 continue;
1363
1364 rc = _usmDHUserKeyTable_set_column(rowreq_ctx,
1365 requests->requestvb,
1366 tri->colnum);
1367 if (MFD_SUCCESS != rc) {
1368 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1369 "usmDHUserKeyTable_set_column\n", rc));
1370 netsnmp_set_request_error(agtreq_info, requests,
1371 SNMP_VALIDATE_ERR(rc));
1372 }
1373 } /* for results */
1374
1375 return SNMP_ERR_NOERROR;
1376 } /* _mfd_usmDHUserKeyTable_set_values */
1377
1378 /*----------------------------------------------------------------------
1379 *
1380 * SET: commit
1381 *
1382 *---------------------------------------------------------------------*/
1383 /**
1384 * @internal
1385 * commit the values
1386 */
1387 int
1388 _mfd_usmDHUserKeyTable_commit(netsnmp_mib_handler *handler,
1389 netsnmp_handler_registration *reginfo,
1390 netsnmp_agent_request_info *agtreq_info,
1391 netsnmp_request_info *requests)
1392 {
1393 int rc;
1394 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1395 netsnmp_container_table_row_extract(requests);
1396
1397 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_commit",
1398 "called\n"));
1399
1400 netsnmp_assert(NULL != rowreq_ctx);
1401
1402 rc = usmDHUserKeyTable_commit(rowreq_ctx);
1403 if (MFD_SUCCESS != rc) {
1404 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1405 "usmDHUserKeyTable_commit\n", rc));
1406 netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
1407 }
1408
1409 if (rowreq_ctx->rowreq_flags & MFD_ROW_DIRTY) {
1410 /*
1411 * if we successfully committed this row, set the dirty flag. Use the
1412 * current value + 1 (i.e. dirty = # rows changed).
1413 * this is checked in post_request...
1414 */
1415 usmDHUserKeyTable_dirty_set(usmDHUserKeyTable_dirty_get() + 1); /* set table dirty flag */
1416 }
1417
1418 return SNMP_ERR_NOERROR;
1419 }
1420
1421 int
1422 _mfd_usmDHUserKeyTable_undo_commit(netsnmp_mib_handler *handler,
1423 netsnmp_handler_registration *reginfo,
1424 netsnmp_agent_request_info *agtreq_info,
1425 netsnmp_request_info *requests)
1426 {
1427 int rc;
1428 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1429 netsnmp_container_table_row_extract(requests);
1430
1431 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_undo_commit", "called\n"));
1432
1433 netsnmp_assert(NULL != rowreq_ctx);
1434
1435 if (rowreq_ctx->rowreq_flags & MFD_ROW_DIRTY) {
1436 u_int d = usmDHUserKeyTable_dirty_get();
1437
1438 netsnmp_assert(d != 0);
1439 if (d)
1440 usmDHUserKeyTable_dirty_set(d - 1);
1441 }
1442
1443 rc = usmDHUserKeyTable_undo_commit(rowreq_ctx);
1444 if (MFD_SUCCESS != rc) {
1445 /*
1446 * nothing we can do about it but log it
1447 */
1448 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1449 "usmDHUserKeyTable_undo_commit\n", rc));
1450 }
1451
1452 if (rowreq_ctx->rowreq_flags & MFD_ROW_DIRTY) {
1453 snmp_log(LOG_WARNING,
1454 "usmDHUserKeyTable row dirty flag still set after undo_commit\n");
1455 rowreq_ctx->rowreq_flags &= ~MFD_ROW_DIRTY;
1456 }
1457
1458 return SNMP_ERR_NOERROR;
1459 } /* _mfd_usmDHUserKeyTable_commit */
1460
1461
1462 /*----------------------------------------------------------------------
1463 *
1464 * SET: Undo
1465 *
1466 *---------------------------------------------------------------------*/
1467 /**
1468 * @internal
1469 * undo the value for a particular column
1470 */
1471 NETSNMP_STATIC_INLINE int
1472 _usmDHUserKeyTable_undo_column(usmDHUserKeyTable_rowreq_ctx * rowreq_ctx,
1473 netsnmp_variable_list * var, int column)
1474 {
1475 int rc = SNMPERR_SUCCESS;
1476
1477 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_undo_column", "called for %d\n", column));
1478
1479 netsnmp_assert(NULL != rowreq_ctx);
1480
1481 switch (column) {
1482
1483 /*
1484 * usmDHUserAuthKeyChange(1)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1485 */
1486 case COLUMN_USMDHUSERAUTHKEYCHANGE:
1487 rc = usmDHUserAuthKeyChange_undo(rowreq_ctx);
1488 break;
1489
1490 /*
1491 * usmDHUserOwnAuthKeyChange(2)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1492 */
1493 case COLUMN_USMDHUSEROWNAUTHKEYCHANGE:
1494 rc = usmDHUserOwnAuthKeyChange_undo(rowreq_ctx);
1495 break;
1496
1497 /*
1498 * usmDHUserPrivKeyChange(3)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1499 */
1500 case COLUMN_USMDHUSERPRIVKEYCHANGE:
1501 rc = usmDHUserPrivKeyChange_undo(rowreq_ctx);
1502 break;
1503
1504 /*
1505 * usmDHUserOwnPrivKeyChange(4)/DHKeyChange/ASN_OCTET_STR/char(char)//L/A/W/e/r/d/h
1506 */
1507 case COLUMN_USMDHUSEROWNPRIVKEYCHANGE:
1508 rc = usmDHUserOwnPrivKeyChange_undo(rowreq_ctx);
1509 break;
1510
1511 default:
1512 snmp_log(LOG_ERR,
1513 "unknown column %d in _usmDHUserKeyTable_undo_column\n",
1514 column);
1515 break;
1516 }
1517
1518 return rc;
1519 } /* _usmDHUserKeyTable_undo_column */
1520
1521 int
1522 _mfd_usmDHUserKeyTable_undo_values(netsnmp_mib_handler *handler,
1523 netsnmp_handler_registration *reginfo,
1524 netsnmp_agent_request_info *agtreq_info,
1525 netsnmp_request_info *requests)
1526 {
1527 int rc;
1528 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1529 netsnmp_container_table_row_extract(requests);
1530 netsnmp_table_request_info *tri;
1531
1532 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_undo_values", "called\n"));
1533
1534 netsnmp_assert(NULL != rowreq_ctx);
1535
1536 rc = usmDHUserKeyTable_undo(rowreq_ctx);
1537 if (MFD_SUCCESS != rc) {
1538 /*
1539 * nothing we can do about it but log it
1540 */
1541 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1542 "usmDHUserKeyTable_undo\n", rc));
1543 }
1544
1545 for (; requests; requests = requests->next) {
1546 /*
1547 * set column data
1548 */
1549 tri = netsnmp_extract_table_info(requests);
1550 if (NULL == tri)
1551 continue;
1552
1553 rc = _usmDHUserKeyTable_undo_column(rowreq_ctx,
1554 requests->requestvb,
1555 tri->colnum);
1556 if (MFD_SUCCESS != rc) {
1557 /*
1558 * nothing we can do about it but log it
1559 */
1560 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1561 "usmDHUserKeyTable_undo_column\n", rc));
1562 }
1563 } /* for results */
1564
1565 return SNMP_ERR_NOERROR;
1566 } /* _mfd_usmDHUserKeyTable_undo_values */
1567
1568 /*----------------------------------------------------------------------
1569 *
1570 * SET: irreversible commit
1571 *
1572 *---------------------------------------------------------------------*/
1573 /**
1574 * @internal
1575 * commit irreversible actions
1576 */
1577 int
1578 _mfd_usmDHUserKeyTable_irreversible_commit(netsnmp_mib_handler *handler, netsnmp_handler_registration
1579 *reginfo, netsnmp_agent_request_info
1580 *agtreq_info,
1581 netsnmp_request_info *requests)
1582 {
1583 int rc;
1584 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx =
1585 netsnmp_container_table_row_extract(requests);
1586
1587 DEBUGMSGTL(("internal:usmDHUserKeyTable:_mfd_usmDHUserKeyTable_irreversible:commit", "called\n"));
1588
1589 netsnmp_assert(NULL != rowreq_ctx);
1590
1591 rc = usmDHUserKeyTable_irreversible_commit(rowreq_ctx);
1592 if (MFD_SUCCESS != rc) {
1593 netsnmp_request_set_error_all(requests, SNMP_ERR_COMMITFAILED);
1594 DEBUGMSGTL(("usmDHUserKeyTable:mfd", "error %d from "
1595 "usmDHUserKeyTable_irreversible_commit\n", rc));
1596 }
1597
1598 /*
1599 * check for and handle row creation/deletion
1600 * and update column exist flags...
1601 */
1602 if (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED) {
1603 CONTAINER_REMOVE(usmDHUserKeyTable_if_ctx.container, rowreq_ctx);
1604 } else {
1605 if (rowreq_ctx->column_set_flags) {
1606 rowreq_ctx->column_set_flags = 0;
1607 }
1608 }
1609
1610 return SNMP_ERR_NOERROR;
1611 } /* _mfd_usmDHUserKeyTable_irreversible_commit */
1612 #endif
1613
1614 /***********************************************************************
1615 *
1616 * DATA ACCESS
1617 *
1618 ***********************************************************************/
1619 static void _container_free(netsnmp_container * container);
1620
1621 /**
1622 * @internal
1623 */
1624 static int
1625 _cache_load(netsnmp_cache * cache, void *vmagic)
1626 {
1627 DEBUGMSGTL(("internal:usmDHUserKeyTable:_cache_load", "called\n"));
1628
1629 if ((NULL == cache) || (NULL == cache->magic)) {
1630 snmp_log(LOG_ERR,
1631 "invalid cache for usmDHUserKeyTable_cache_load\n");
1632 return -1;
1633 }
1634
1635 /** should only be called for an invalid or expired cache */
1636 netsnmp_assert((0 == cache->valid) || (1 == cache->expired));
1637
1638 /*
1639 * call user code
1640 */
1641 return usmDHUserKeyTable_container_load((netsnmp_container *) cache->
1642 magic);
1643 } /* _cache_load */
1644
1645 /**
1646 * @internal
1647 */
1648 static void
1649 _cache_free(netsnmp_cache * cache, void *magic)
1650 {
1651 netsnmp_container *container;
1652
1653 DEBUGMSGTL(("internal:usmDHUserKeyTable:_cache_free", "called\n"));
1654
1655 if ((NULL == cache) || (NULL == cache->magic)) {
1656 snmp_log(LOG_ERR,
1657 "invalid cache in usmDHUserKeyTable_cache_free\n");
1658 return;
1659 }
1660
1661 container = (netsnmp_container *) cache->magic;
1662
1663 _container_free(container);
1664 } /* _cache_free */
1665
1666 /**
1667 * @internal
1668 */
1669 static void
1670 _container_item_free(void *rowreq_ctx, void *context)
1671 {
1672 DEBUGMSGTL(("internal:usmDHUserKeyTable:_container_item_free",
1673 "called\n"));
1674
1675 if (NULL == rowreq_ctx)
1676 return;
1677
1678 usmDHUserKeyTable_release_rowreq_ctx(rowreq_ctx);
1679 } /* _container_item_free */
1680
1681 /**
1682 * @internal
1683 */
1684 static void
1685 _container_free(netsnmp_container * container)
1686 {
1687 DEBUGMSGTL(("internal:usmDHUserKeyTable:_container_free", "called\n"));
1688
1689 if (NULL == container) {
1690 snmp_log(LOG_ERR,
1691 "invalid container in usmDHUserKeyTable_container_free\n");
1692 return;
1693 }
1694
1695 /*
1696 * call user code
1697 */
1698 usmDHUserKeyTable_container_free(container);
1699
1700 /*
1701 * free all items. inefficient, but easy.
1702 */
1703 CONTAINER_CLEAR(container, _container_item_free, NULL);
1704 } /* _container_free */
1705
1706 /**
1707 * @internal
1708 * initialize the container with functions or wrappers
1709 */
1710 void
1711 _usmDHUserKeyTable_container_init(usmDHUserKeyTable_interface_ctx * if_ctx)
1712 {
1713 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_container_init", "called\n"));
1714
1715 /*
1716 * cache init
1717 */
1718 if_ctx->cache = netsnmp_cache_create(30, /* timeout in seconds */
1719 _cache_load, _cache_free,
1720 usmDHUserKeyTable_oid,
1721 usmDHUserKeyTable_oid_size);
1722
1723 if (NULL == if_ctx->cache) {
1724 snmp_log(LOG_ERR, "error creating cache for usmDHUserKeyTable\n");
1725 return;
1726 }
1727
1728 if_ctx->cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
1729
1730 usmDHUserKeyTable_container_init(&if_ctx->container, if_ctx->cache);
1731 if (NULL == if_ctx->container)
1732 if_ctx->container =
1733 netsnmp_container_find("usmDHUserKeyTable:table_container");
1734 if (NULL == if_ctx->container) {
1735 snmp_log(LOG_ERR, "error creating container in "
1736 "usmDHUserKeyTable_container_init\n");
1737 return;
1738 }
1739
1740 if (NULL != if_ctx->cache)
1741 if_ctx->cache->magic = (void *) if_ctx->container;
1742 } /* _usmDHUserKeyTable_container_init */
1743
1744 /**
1745 * @internal
1746 * shutdown the container with functions or wrappers
1747 */
1748 void
1749 _usmDHUserKeyTable_container_shutdown(usmDHUserKeyTable_interface_ctx *
1750 if_ctx)
1751 {
1752 DEBUGMSGTL(("internal:usmDHUserKeyTable:_usmDHUserKeyTable_container_shutdown", "called\n"));
1753
1754 usmDHUserKeyTable_container_shutdown(if_ctx->container);
1755
1756 _container_free(if_ctx->container);
1757
1758 } /* _usmDHUserKeyTable_container_shutdown */
1759
1760
1761 usmDHUserKeyTable_rowreq_ctx *
1762 usmDHUserKeyTable_row_find_by_mib_index(usmDHUserKeyTable_mib_index *
1763 mib_idx)
1764 {
1765 usmDHUserKeyTable_rowreq_ctx *rowreq_ctx;
1766 oid oid_tmp[MAX_OID_LEN];
1767 netsnmp_index oid_idx;
1768 int rc;
1769
1770 /*
1771 * set up storage for OID
1772 */
1773 oid_idx.oids = oid_tmp;
1774 oid_idx.len = sizeof(oid_tmp) / sizeof(oid);
1775
1776 /*
1777 * convert
1778 */
1779 rc = usmDHUserKeyTable_index_to_oid(&oid_idx, mib_idx);
1780 if (MFD_SUCCESS != rc)
1781 return NULL;
1782
1783 rowreq_ctx =
1784 CONTAINER_FIND(usmDHUserKeyTable_if_ctx.container, &oid_idx);
1785
1786 return rowreq_ctx;
1787 }