← Back to branch summary

~ubuntu-branches/ubuntu/trusty/net-snmp/trusty

« back to all changes in this revision

Viewing changes to agent/mibgroup/ip-mib/ipAddressPrefixTable/ipAddressPrefixTable_interface.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-05-10 22:20:23 UTC
  • mto: (1.4.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: james.westby@ubuntu.com-20070510222023-3fr07xb9i17xvq32
Tags: upstream-5.3.1
Import upstream version 5.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
agent/mibgroup/ip-mib/ipAddressPrefixTable/ipAddressPrefixTable_interface.c
 
1
/*
 
2
 * Note: this file originally auto-generated by mib2c using
 
3
 *       version : 1.67 $ of : mfd-interface.m2c,v $ 
 
4
 *
 
5
 * $Id: ipAddressPrefixTable_interface.c,v 1.2 2005/12/01 15:49:39 rstory Exp $
 
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-includes.h>
 
34
#include <net-snmp/agent/net-snmp-agent-includes.h>
 
35
 
 
36
/*
 
37
 * include our parent header 
 
38
 */
 
39
#include "ipAddressPrefixTable.h"
 
40
 
 
41
 
 
42
#include <net-snmp/agent/table_container.h>
 
43
#include <net-snmp/library/container.h>
 
44
 
 
45
#include "ipAddressPrefixTable_interface.h"
 
46
 
 
47
#include <ctype.h>
 
48
 
 
49
/**********************************************************************
 
50
 **********************************************************************
 
51
 ***
 
52
 *** Table ipAddressPrefixTable
 
53
 ***
 
54
 **********************************************************************
 
55
 **********************************************************************/
 
56
/*
 
57
 * IP-MIB::ipAddressPrefixTable is subid 32 of ip.
 
58
 * Its status is Current.
 
59
 * OID: .1.3.6.1.2.1.4.32, length: 8
 
60
 */
 
61
typedef struct ipAddressPrefixTable_interface_ctx_s {
 
62
 
 
63
    netsnmp_container *container;
 
64
    netsnmp_cache  *cache;
 
65
 
 
66
    ipAddressPrefixTable_registration *user_ctx;
 
67
 
 
68
    netsnmp_table_registration_info tbl_info;
 
69
 
 
70
    netsnmp_baby_steps_access_methods access_multiplexer;
 
71
 
 
72
} ipAddressPrefixTable_interface_ctx;
 
73
 
 
74
static ipAddressPrefixTable_interface_ctx ipAddressPrefixTable_if_ctx;
 
75
 
 
76
static void
 
77
                _ipAddressPrefixTable_container_init(ipAddressPrefixTable_interface_ctx *
 
78
                                                     if_ctx);
 
79
static void
 
80
                _ipAddressPrefixTable_container_shutdown(ipAddressPrefixTable_interface_ctx
 
81
                                                         * if_ctx);
 
82
 
 
83
 
 
84
netsnmp_container *
 
85
ipAddressPrefixTable_container_get(void)
 
86
{
 
87
    return ipAddressPrefixTable_if_ctx.container;
 
88
}
 
89
 
 
90
ipAddressPrefixTable_registration *
 
91
ipAddressPrefixTable_registration_get(void)
 
92
{
 
93
    return ipAddressPrefixTable_if_ctx.user_ctx;
 
94
}
 
95
 
 
96
ipAddressPrefixTable_registration *
 
97
ipAddressPrefixTable_registration_set(ipAddressPrefixTable_registration *
 
98
                                      newreg)
 
99
{
 
100
    ipAddressPrefixTable_registration *old =
 
101
        ipAddressPrefixTable_if_ctx.user_ctx;
 
102
    ipAddressPrefixTable_if_ctx.user_ctx = newreg;
 
103
    return old;
 
104
}
 
105
 
 
106
int
 
107
ipAddressPrefixTable_container_size(void)
 
108
{
 
109
    return CONTAINER_SIZE(ipAddressPrefixTable_if_ctx.container);
 
110
}
 
111
 
 
112
/*
 
113
 * mfd multiplexer modes
 
114
 */
 
115
static Netsnmp_Node_Handler _mfd_ipAddressPrefixTable_pre_request;
 
116
static Netsnmp_Node_Handler _mfd_ipAddressPrefixTable_post_request;
 
117
static Netsnmp_Node_Handler _mfd_ipAddressPrefixTable_object_lookup;
 
118
static Netsnmp_Node_Handler _mfd_ipAddressPrefixTable_get_values;
 
119
/**
 
120
 * @internal
 
121
 * Initialize the table ipAddressPrefixTable 
 
122
 *    (Define its contents and how it's structured)
 
123
 */
 
124
void
 
125
    _ipAddressPrefixTable_initialize_interface
 
126
    (ipAddressPrefixTable_registration * reg_ptr, u_long flags)
 
127
{
 
128
    netsnmp_baby_steps_access_methods *access_multiplexer =
 
129
        &ipAddressPrefixTable_if_ctx.access_multiplexer;
 
130
    netsnmp_table_registration_info *tbl_info =
 
131
        &ipAddressPrefixTable_if_ctx.tbl_info;
 
132
    netsnmp_handler_registration *reginfo;
 
133
    netsnmp_mib_handler *handler;
 
134
    int             mfd_modes = 0;
 
135
 
 
136
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_ipAddressPrefixTable_initialize_interface", "called\n"));
 
137
 
 
138
 
 
139
    /*************************************************
 
140
     *
 
141
     * save interface context for ipAddressPrefixTable
 
142
     */
 
143
    /*
 
144
     * Setting up the table's definition
 
145
     */
 
146
    netsnmp_table_helper_add_indexes(tbl_info, ASN_INTEGER,
 
147
                                               /** index: ipAddressPrefixIfIndex */
 
148
                                     ASN_INTEGER,
 
149
                                               /** index: ipAddressPrefixType */
 
150
                                     ASN_OCTET_STR,
 
151
                                                 /** index: ipAddressPrefixPrefix */
 
152
                                     ASN_UNSIGNED,
 
153
                                                /** index: ipAddressPrefixLength */
 
154
                                     0);
 
155
 
 
156
    /*
 
157
     * Define the minimum and maximum accessible columns.  This
 
158
     * optimizes retrival. 
 
159
     */
 
160
    tbl_info->min_column = IPADDRESSPREFIXTABLE_MIN_COL;
 
161
    tbl_info->max_column = IPADDRESSPREFIXTABLE_MAX_COL;
 
162
 
 
163
    /*
 
164
     * save users context
 
165
     */
 
166
    ipAddressPrefixTable_if_ctx.user_ctx = reg_ptr;
 
167
 
 
168
    /*
 
169
     * call data access initialization code
 
170
     */
 
171
    ipAddressPrefixTable_init_data(reg_ptr);
 
172
 
 
173
    /*
 
174
     * set up the container
 
175
     */
 
176
    _ipAddressPrefixTable_container_init(&ipAddressPrefixTable_if_ctx);
 
177
    if (NULL == ipAddressPrefixTable_if_ctx.container) {
 
178
        snmp_log(LOG_ERR,
 
179
                 "could not initialize container for ipAddressPrefixTable\n");
 
180
        return;
 
181
    }
 
182
 
 
183
    /*
 
184
     * access_multiplexer: REQUIRED wrapper for get request handling
 
185
     */
 
186
    access_multiplexer->object_lookup =
 
187
        _mfd_ipAddressPrefixTable_object_lookup;
 
188
    access_multiplexer->get_values = _mfd_ipAddressPrefixTable_get_values;
 
189
 
 
190
    /*
 
191
     * no wrappers yet
 
192
     */
 
193
    access_multiplexer->pre_request =
 
194
        _mfd_ipAddressPrefixTable_pre_request;
 
195
    access_multiplexer->post_request =
 
196
        _mfd_ipAddressPrefixTable_post_request;
 
197
 
 
198
 
 
199
    /*************************************************
 
200
     *
 
201
     * Create a registration, save our reg data, register table.
 
202
     */
 
203
    DEBUGMSGTL(("ipAddressPrefixTable:init_ipAddressPrefixTable",
 
204
                "Registering ipAddressPrefixTable as a mibs-for-dummies table.\n"));
 
205
    handler =
 
206
        netsnmp_baby_steps_access_multiplexer_get(access_multiplexer);
 
207
    reginfo =
 
208
        netsnmp_handler_registration_create("ipAddressPrefixTable",
 
209
                                            handler,
 
210
                                            ipAddressPrefixTable_oid,
 
211
                                            ipAddressPrefixTable_oid_size,
 
212
                                            HANDLER_CAN_BABY_STEP |
 
213
                                            HANDLER_CAN_RONLY);
 
214
    if (NULL == reginfo) {
 
215
        snmp_log(LOG_ERR,
 
216
                 "error registering table ipAddressPrefixTable\n");
 
217
        return;
 
218
    }
 
219
    reginfo->my_reg_void = &ipAddressPrefixTable_if_ctx;
 
220
 
 
221
    /*************************************************
 
222
     *
 
223
     * set up baby steps handler, create it and inject it
 
224
     */
 
225
    if (access_multiplexer->object_lookup)
 
226
        mfd_modes |= BABY_STEP_OBJECT_LOOKUP;
 
227
    if (access_multiplexer->set_values)
 
228
        mfd_modes |= BABY_STEP_SET_VALUES;
 
229
    if (access_multiplexer->irreversible_commit)
 
230
        mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT;
 
231
    if (access_multiplexer->object_syntax_checks)
 
232
        mfd_modes |= BABY_STEP_CHECK_OBJECT;
 
233
 
 
234
    if (access_multiplexer->pre_request)
 
235
        mfd_modes |= BABY_STEP_PRE_REQUEST;
 
236
    if (access_multiplexer->post_request)
 
237
        mfd_modes |= BABY_STEP_POST_REQUEST;
 
238
 
 
239
    if (access_multiplexer->undo_setup)
 
240
        mfd_modes |= BABY_STEP_UNDO_SETUP;
 
241
    if (access_multiplexer->undo_cleanup)
 
242
        mfd_modes |= BABY_STEP_UNDO_CLEANUP;
 
243
    if (access_multiplexer->undo_sets)
 
244
        mfd_modes |= BABY_STEP_UNDO_SETS;
 
245
 
 
246
    if (access_multiplexer->row_creation)
 
247
        mfd_modes |= BABY_STEP_ROW_CREATE;
 
248
    if (access_multiplexer->consistency_checks)
 
249
        mfd_modes |= BABY_STEP_CHECK_CONSISTENCY;
 
250
    if (access_multiplexer->commit)
 
251
        mfd_modes |= BABY_STEP_COMMIT;
 
252
    if (access_multiplexer->undo_commit)
 
253
        mfd_modes |= BABY_STEP_UNDO_COMMIT;
 
254
 
 
255
    handler = netsnmp_baby_steps_handler_get(mfd_modes);
 
256
    netsnmp_inject_handler(reginfo, handler);
 
257
 
 
258
    /*************************************************
 
259
     *
 
260
     * inject row_merge helper with prefix rootoid_len + 2 (entry.col)
 
261
     */
 
262
    handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2);
 
263
    netsnmp_inject_handler(reginfo, handler);
 
264
 
 
265
    /*************************************************
 
266
     *
 
267
     * inject container_table helper
 
268
     */
 
269
    handler =
 
270
        netsnmp_container_table_handler_get(tbl_info,
 
271
                                            ipAddressPrefixTable_if_ctx.
 
272
                                            container,
 
273
                                            TABLE_CONTAINER_KEY_NETSNMP_INDEX);
 
274
    netsnmp_inject_handler(reginfo, handler);
 
275
 
 
276
    /*************************************************
 
277
     *
 
278
     * inject cache helper
 
279
     */
 
280
    if (NULL != ipAddressPrefixTable_if_ctx.cache) {
 
281
        handler =
 
282
            netsnmp_cache_handler_get(ipAddressPrefixTable_if_ctx.cache);
 
283
        netsnmp_inject_handler(reginfo, handler);
 
284
    }
 
285
 
 
286
    /*
 
287
     * register table
 
288
     */
 
289
    netsnmp_register_table(reginfo, tbl_info);
 
290
 
 
291
}                               /* _ipAddressPrefixTable_initialize_interface */
 
292
 
 
293
/**
 
294
 * @internal
 
295
 * Shutdown the table ipAddressPrefixTable
 
296
 */
 
297
void
 
298
_ipAddressPrefixTable_shutdown_interface(ipAddressPrefixTable_registration
 
299
                                         * reg_ptr)
 
300
{
 
301
    /*
 
302
     * shutdown the container
 
303
     */
 
304
    _ipAddressPrefixTable_container_shutdown(&ipAddressPrefixTable_if_ctx);
 
305
}
 
306
 
 
307
void
 
308
ipAddressPrefixTable_valid_columns_set(netsnmp_column_info *vc)
 
309
{
 
310
    ipAddressPrefixTable_if_ctx.tbl_info.valid_columns = vc;
 
311
}                               /* ipAddressPrefixTable_valid_columns_set */
 
312
 
 
313
/**
 
314
 * @internal
 
315
 * convert the index component stored in the context to an oid
 
316
 */
 
317
int
 
318
ipAddressPrefixTable_index_to_oid(netsnmp_index * oid_idx,
 
319
                                  ipAddressPrefixTable_mib_index * mib_idx)
 
320
{
 
321
    int             err = SNMP_ERR_NOERROR;
 
322
 
 
323
    /*
 
324
     * temp storage for parsing indexes
 
325
     */
 
326
    /*
 
327
     * ipAddressPrefixIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
 
328
     */
 
329
    netsnmp_variable_list var_ipAddressPrefixIfIndex;
 
330
    /*
 
331
     * ipAddressPrefixType(2)/InetAddressType/ASN_INTEGER/long(u_long)//l/a/w/E/r/d/h
 
332
     */
 
333
    netsnmp_variable_list var_ipAddressPrefixType;
 
334
    /*
 
335
     * ipAddressPrefixPrefix(3)/InetAddress/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h
 
336
     */
 
337
    netsnmp_variable_list var_ipAddressPrefixPrefix;
 
338
    /*
 
339
     * ipAddressPrefixLength(4)/InetAddressPrefixLength/ASN_UNSIGNED/u_long(u_long)//l/a/w/e/R/d/H
 
340
     */
 
341
    netsnmp_variable_list var_ipAddressPrefixLength;
 
342
 
 
343
    /*
 
344
     * set up varbinds
 
345
     */
 
346
    memset(&var_ipAddressPrefixIfIndex, 0x00,
 
347
           sizeof(var_ipAddressPrefixIfIndex));
 
348
    var_ipAddressPrefixIfIndex.type = ASN_INTEGER;
 
349
    memset(&var_ipAddressPrefixType, 0x00,
 
350
           sizeof(var_ipAddressPrefixType));
 
351
    var_ipAddressPrefixType.type = ASN_INTEGER;
 
352
    memset(&var_ipAddressPrefixPrefix, 0x00,
 
353
           sizeof(var_ipAddressPrefixPrefix));
 
354
    var_ipAddressPrefixPrefix.type = ASN_OCTET_STR;
 
355
    memset(&var_ipAddressPrefixLength, 0x00,
 
356
           sizeof(var_ipAddressPrefixLength));
 
357
    var_ipAddressPrefixLength.type = ASN_UNSIGNED;
 
358
 
 
359
    /*
 
360
     * chain temp index varbinds together
 
361
     */
 
362
    var_ipAddressPrefixIfIndex.next_variable = &var_ipAddressPrefixType;
 
363
    var_ipAddressPrefixType.next_variable = &var_ipAddressPrefixPrefix;
 
364
    var_ipAddressPrefixPrefix.next_variable = &var_ipAddressPrefixLength;
 
365
    var_ipAddressPrefixLength.next_variable = NULL;
 
366
 
 
367
 
 
368
    DEBUGMSGTL(("verbose:ipAddressPrefixTable:ipAddressPrefixTable_index_to_oid", "called\n"));
 
369
 
 
370
    /*
 
371
     * ipAddressPrefixIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H 
 
372
     */
 
373
    snmp_set_var_value(&var_ipAddressPrefixIfIndex,
 
374
                       (u_char *) & mib_idx->ipAddressPrefixIfIndex,
 
375
                       sizeof(mib_idx->ipAddressPrefixIfIndex));
 
376
 
 
377
    /*
 
378
     * ipAddressPrefixType(2)/InetAddressType/ASN_INTEGER/long(u_long)//l/a/w/E/r/d/h 
 
379
     */
 
380
    snmp_set_var_value(&var_ipAddressPrefixType,
 
381
                       (u_char *) & mib_idx->ipAddressPrefixType,
 
382
                       sizeof(mib_idx->ipAddressPrefixType));
 
383
 
 
384
    /*
 
385
     * ipAddressPrefixPrefix(3)/InetAddress/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h 
 
386
     */
 
387
    snmp_set_var_value(&var_ipAddressPrefixPrefix,
 
388
                       (u_char *) & mib_idx->ipAddressPrefixPrefix,
 
389
                       mib_idx->ipAddressPrefixPrefix_len *
 
390
                       sizeof(mib_idx->ipAddressPrefixPrefix[0]));
 
391
 
 
392
    /*
 
393
     * ipAddressPrefixLength(4)/InetAddressPrefixLength/ASN_UNSIGNED/u_long(u_long)//l/a/w/e/R/d/H 
 
394
     */
 
395
    snmp_set_var_value(&var_ipAddressPrefixLength,
 
396
                       (u_char *) & mib_idx->ipAddressPrefixLength,
 
397
                       sizeof(mib_idx->ipAddressPrefixLength));
 
398
 
 
399
 
 
400
    err = build_oid_noalloc(oid_idx->oids, oid_idx->len, &oid_idx->len,
 
401
                            NULL, 0, &var_ipAddressPrefixIfIndex);
 
402
    if (err)
 
403
        snmp_log(LOG_ERR, "error %d converting index to oid\n", err);
 
404
 
 
405
    /*
 
406
     * parsing may have allocated memory. free it.
 
407
     */
 
408
    snmp_reset_var_buffers(&var_ipAddressPrefixIfIndex);
 
409
 
 
410
    return err;
 
411
}                               /* ipAddressPrefixTable_index_to_oid */
 
412
 
 
413
/**
 
414
 * extract ipAddressPrefixTable indexes from a netsnmp_index
 
415
 *
 
416
 * @retval SNMP_ERR_NOERROR  : no error
 
417
 * @retval SNMP_ERR_GENERR   : error
 
418
 */
 
419
int
 
420
ipAddressPrefixTable_index_from_oid(netsnmp_index * oid_idx,
 
421
                                    ipAddressPrefixTable_mib_index *
 
422
                                    mib_idx)
 
423
{
 
424
    int             err = SNMP_ERR_NOERROR;
 
425
 
 
426
    /*
 
427
     * temp storage for parsing indexes
 
428
     */
 
429
    /*
 
430
     * ipAddressPrefixIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
 
431
     */
 
432
    netsnmp_variable_list var_ipAddressPrefixIfIndex;
 
433
    /*
 
434
     * ipAddressPrefixType(2)/InetAddressType/ASN_INTEGER/long(u_long)//l/a/w/E/r/d/h
 
435
     */
 
436
    netsnmp_variable_list var_ipAddressPrefixType;
 
437
    /*
 
438
     * ipAddressPrefixPrefix(3)/InetAddress/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h
 
439
     */
 
440
    netsnmp_variable_list var_ipAddressPrefixPrefix;
 
441
    /*
 
442
     * ipAddressPrefixLength(4)/InetAddressPrefixLength/ASN_UNSIGNED/u_long(u_long)//l/a/w/e/R/d/H
 
443
     */
 
444
    netsnmp_variable_list var_ipAddressPrefixLength;
 
445
 
 
446
    /*
 
447
     * set up varbinds
 
448
     */
 
449
    memset(&var_ipAddressPrefixIfIndex, 0x00,
 
450
           sizeof(var_ipAddressPrefixIfIndex));
 
451
    var_ipAddressPrefixIfIndex.type = ASN_INTEGER;
 
452
    memset(&var_ipAddressPrefixType, 0x00,
 
453
           sizeof(var_ipAddressPrefixType));
 
454
    var_ipAddressPrefixType.type = ASN_INTEGER;
 
455
    memset(&var_ipAddressPrefixPrefix, 0x00,
 
456
           sizeof(var_ipAddressPrefixPrefix));
 
457
    var_ipAddressPrefixPrefix.type = ASN_OCTET_STR;
 
458
    memset(&var_ipAddressPrefixLength, 0x00,
 
459
           sizeof(var_ipAddressPrefixLength));
 
460
    var_ipAddressPrefixLength.type = ASN_UNSIGNED;
 
461
 
 
462
    /*
 
463
     * chain temp index varbinds together
 
464
     */
 
465
    var_ipAddressPrefixIfIndex.next_variable = &var_ipAddressPrefixType;
 
466
    var_ipAddressPrefixType.next_variable = &var_ipAddressPrefixPrefix;
 
467
    var_ipAddressPrefixPrefix.next_variable = &var_ipAddressPrefixLength;
 
468
    var_ipAddressPrefixLength.next_variable = NULL;
 
469
 
 
470
 
 
471
    DEBUGMSGTL(("verbose:ipAddressPrefixTable:ipAddressPrefixTable_index_from_oid", "called\n"));
 
472
 
 
473
    /*
 
474
     * parse the oid into the individual index components
 
475
     */
 
476
    err = parse_oid_indexes(oid_idx->oids, oid_idx->len,
 
477
                            &var_ipAddressPrefixIfIndex);
 
478
    if (err == SNMP_ERR_NOERROR) {
 
479
        /*
 
480
         * copy out values
 
481
         */
 
482
        mib_idx->ipAddressPrefixIfIndex =
 
483
            *((long *) var_ipAddressPrefixIfIndex.val.string);
 
484
        mib_idx->ipAddressPrefixType =
 
485
            *((u_long *) var_ipAddressPrefixType.val.string);
 
486
        /*
 
487
         * NOTE: val_len is in bytes, ipAddressPrefixPrefix_len might not be
 
488
         */
 
489
        if (var_ipAddressPrefixPrefix.val_len >
 
490
            sizeof(mib_idx->ipAddressPrefixPrefix))
 
491
            err = SNMP_ERR_GENERR;
 
492
        else {
 
493
            memcpy(mib_idx->ipAddressPrefixPrefix,
 
494
                   var_ipAddressPrefixPrefix.val.string,
 
495
                   var_ipAddressPrefixPrefix.val_len);
 
496
            mib_idx->ipAddressPrefixPrefix_len =
 
497
                var_ipAddressPrefixPrefix.val_len /
 
498
                sizeof(mib_idx->ipAddressPrefixPrefix[0]);
 
499
        }
 
500
        mib_idx->ipAddressPrefixLength =
 
501
            *((u_long *) var_ipAddressPrefixLength.val.string);
 
502
 
 
503
 
 
504
    }
 
505
 
 
506
    /*
 
507
     * parsing may have allocated memory. free it.
 
508
     */
 
509
    snmp_reset_var_buffers(&var_ipAddressPrefixIfIndex);
 
510
 
 
511
    return err;
 
512
}                               /* ipAddressPrefixTable_index_from_oid */
 
513
 
 
514
 
 
515
/*
 
516
 *********************************************************************
 
517
 * @internal
 
518
 * allocate resources for a ipAddressPrefixTable_rowreq_ctx
 
519
 */
 
520
ipAddressPrefixTable_rowreq_ctx *
 
521
ipAddressPrefixTable_allocate_rowreq_ctx(void *user_init_ctx)
 
522
{
 
523
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
 
524
        SNMP_MALLOC_TYPEDEF(ipAddressPrefixTable_rowreq_ctx);
 
525
 
 
526
    DEBUGMSGTL(("internal:ipAddressPrefixTable:ipAddressPrefixTable_allocate_rowreq_ctx", "called\n"));
 
527
 
 
528
    if (NULL == rowreq_ctx) {
 
529
        snmp_log(LOG_ERR, "Couldn't allocate memory for a "
 
530
                 "ipAddressPrefixTable_rowreq_ctx.\n");
 
531
    }
 
532
 
 
533
    rowreq_ctx->oid_idx.oids = rowreq_ctx->oid_tmp;
 
534
 
 
535
    rowreq_ctx->ipAddressPrefixTable_data_list = NULL;
 
536
 
 
537
    /*
 
538
     * if we allocated data, call init routine
 
539
     */
 
540
    if (!(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER)) {
 
541
        if (SNMPERR_SUCCESS !=
 
542
            ipAddressPrefixTable_rowreq_ctx_init(rowreq_ctx,
 
543
                                                 user_init_ctx)) {
 
544
            ipAddressPrefixTable_release_rowreq_ctx(rowreq_ctx);
 
545
            rowreq_ctx = NULL;
 
546
        }
 
547
    }
 
548
 
 
549
    return rowreq_ctx;
 
550
}                               /* ipAddressPrefixTable_allocate_rowreq_ctx */
 
551
 
 
552
/*
 
553
 * @internal
 
554
 * release resources for a ipAddressPrefixTable_rowreq_ctx
 
555
 */
 
556
void
 
557
ipAddressPrefixTable_release_rowreq_ctx(ipAddressPrefixTable_rowreq_ctx *
 
558
                                        rowreq_ctx)
 
559
{
 
560
    DEBUGMSGTL(("internal:ipAddressPrefixTable:ipAddressPrefixTable_release_rowreq_ctx", "called\n"));
 
561
 
 
562
    netsnmp_assert(NULL != rowreq_ctx);
 
563
 
 
564
    ipAddressPrefixTable_rowreq_ctx_cleanup(rowreq_ctx);
 
565
 
 
566
    /*
 
567
     * free index oid pointer
 
568
     */
 
569
    if (rowreq_ctx->oid_idx.oids != rowreq_ctx->oid_tmp)
 
570
        free(rowreq_ctx->oid_idx.oids);
 
571
 
 
572
    SNMP_FREE(rowreq_ctx);
 
573
}                               /* ipAddressPrefixTable_release_rowreq_ctx */
 
574
 
 
575
/**
 
576
 * @internal
 
577
 * wrapper
 
578
 */
 
579
static int
 
580
_mfd_ipAddressPrefixTable_pre_request(netsnmp_mib_handler *handler, netsnmp_handler_registration
 
581
                                      *reginfo, netsnmp_agent_request_info
 
582
                                      *agtreq_info,
 
583
                                      netsnmp_request_info *requests)
 
584
{
 
585
    int             rc;
 
586
 
 
587
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_pre_request", "called\n"));
 
588
 
 
589
    if (1 != netsnmp_row_merge_status_first(reginfo, agtreq_info)) {
 
590
        DEBUGMSGTL(("internal:ipAddressPrefixTable",
 
591
                    "skipping additional pre_request\n"));
 
592
        return SNMP_ERR_NOERROR;
 
593
    }
 
594
 
 
595
    rc = ipAddressPrefixTable_pre_request(ipAddressPrefixTable_if_ctx.
 
596
                                          user_ctx);
 
597
    if (MFD_SUCCESS != rc) {
 
598
        /*
 
599
         * nothing we can do about it but log it
 
600
         */
 
601
        DEBUGMSGTL(("ipAddressPrefixTable", "error %d from "
 
602
                    "ipAddressPrefixTable_pre_request\n", rc));
 
603
        netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
 
604
    }
 
605
 
 
606
    return SNMP_ERR_NOERROR;
 
607
}                               /* _mfd_ipAddressPrefixTable_pre_request */
 
608
 
 
609
/**
 
610
 * @internal
 
611
 * wrapper
 
612
 */
 
613
static int
 
614
_mfd_ipAddressPrefixTable_post_request(netsnmp_mib_handler *handler, netsnmp_handler_registration
 
615
                                       *reginfo, netsnmp_agent_request_info
 
616
                                       *agtreq_info,
 
617
                                       netsnmp_request_info *requests)
 
618
{
 
619
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
 
620
        netsnmp_container_table_row_extract(requests);
 
621
    int             rc, packet_rc;
 
622
 
 
623
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_post_request", "called\n"));
 
624
 
 
625
    /*
 
626
     * release row context, if deleted
 
627
     */
 
628
    if (rowreq_ctx && (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED))
 
629
        ipAddressPrefixTable_release_rowreq_ctx(rowreq_ctx);
 
630
 
 
631
    /*
 
632
     * wait for last call before calling user
 
633
     */
 
634
    if (1 != netsnmp_row_merge_status_last(reginfo, agtreq_info)) {
 
635
        DEBUGMSGTL(("internal:ipAddressPrefixTable",
 
636
                    "waiting for last post_request\n"));
 
637
        return SNMP_ERR_NOERROR;
 
638
    }
 
639
 
 
640
    packet_rc = netsnmp_check_all_requests_error(agtreq_info->asp, 0);
 
641
    rc = ipAddressPrefixTable_post_request(ipAddressPrefixTable_if_ctx.
 
642
                                           user_ctx, packet_rc);
 
643
    if (MFD_SUCCESS != rc) {
 
644
        /*
 
645
         * nothing we can do about it but log it
 
646
         */
 
647
        DEBUGMSGTL(("ipAddressPrefixTable", "error %d from "
 
648
                    "ipAddressPrefixTable_post_request\n", rc));
 
649
    }
 
650
 
 
651
    return SNMP_ERR_NOERROR;
 
652
}                               /* _mfd_ipAddressPrefixTable_post_request */
 
653
 
 
654
/**
 
655
 * @internal
 
656
 * wrapper
 
657
 */
 
658
static int
 
659
_mfd_ipAddressPrefixTable_object_lookup(netsnmp_mib_handler *handler, netsnmp_handler_registration
 
660
                                        *reginfo, netsnmp_agent_request_info
 
661
                                        *agtreq_info,
 
662
                                        netsnmp_request_info *requests)
 
663
{
 
664
    int             rc = SNMP_ERR_NOERROR;
 
665
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
 
666
        netsnmp_container_table_row_extract(requests);
 
667
 
 
668
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_object_lookup", "called\n"));
 
669
 
 
670
    /*
 
671
     * get our context from mfd
 
672
     * ipAddressPrefixTable_interface_ctx *if_ctx =
 
673
     *             (ipAddressPrefixTable_interface_ctx *)reginfo->my_reg_void;
 
674
     */
 
675
 
 
676
    if (NULL == rowreq_ctx) {
 
677
        rc = SNMP_ERR_NOCREATION;
 
678
    }
 
679
 
 
680
    if (MFD_SUCCESS != rc)
 
681
        netsnmp_request_set_error_all(requests, rc);
 
682
    else
 
683
        ipAddressPrefixTable_row_prep(rowreq_ctx);
 
684
 
 
685
    return SNMP_VALIDATE_ERR(rc);
 
686
}                               /* _mfd_ipAddressPrefixTable_object_lookup */
 
687
 
 
688
/***********************************************************************
 
689
 *
 
690
 * GET processing
 
691
 *
 
692
 ***********************************************************************/
 
693
/*
 
694
 * @internal
 
695
 * Retrieve the value for a particular column
 
696
 */
 
697
NETSNMP_STATIC_INLINE int
 
698
_ipAddressPrefixTable_get_column(ipAddressPrefixTable_rowreq_ctx *
 
699
                                 rowreq_ctx, netsnmp_variable_list * var,
 
700
                                 int column)
 
701
{
 
702
    int             rc = SNMPERR_SUCCESS;
 
703
 
 
704
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_get_column", "called for %d\n", column));
 
705
 
 
706
 
 
707
    netsnmp_assert(NULL != rowreq_ctx);
 
708
 
 
709
    switch (column) {
 
710
 
 
711
        /*
 
712
         * ipAddressPrefixOrigin(5)/IpAddressPrefixOriginTC/ASN_INTEGER/long(u_long)//l/A/w/E/r/d/h 
 
713
         */
 
714
    case COLUMN_IPADDRESSPREFIXORIGIN:
 
715
        var->val_len = sizeof(u_long);
 
716
        var->type = ASN_INTEGER;
 
717
        rc = ipAddressPrefixOrigin_get(rowreq_ctx,
 
718
                                       (u_long *) var->val.string);
 
719
        break;
 
720
 
 
721
        /*
 
722
         * ipAddressPrefixOnLinkFlag(6)/TruthValue/ASN_INTEGER/long(u_long)//l/A/w/E/r/d/h 
 
723
         */
 
724
    case COLUMN_IPADDRESSPREFIXONLINKFLAG:
 
725
        var->val_len = sizeof(u_long);
 
726
        var->type = ASN_INTEGER;
 
727
        rc = ipAddressPrefixOnLinkFlag_get(rowreq_ctx,
 
728
                                           (u_long *) var->val.string);
 
729
        break;
 
730
 
 
731
        /*
 
732
         * ipAddressPrefixAutonomousFlag(7)/TruthValue/ASN_INTEGER/long(u_long)//l/A/w/E/r/d/h 
 
733
         */
 
734
    case COLUMN_IPADDRESSPREFIXAUTONOMOUSFLAG:
 
735
        var->val_len = sizeof(u_long);
 
736
        var->type = ASN_INTEGER;
 
737
        rc = ipAddressPrefixAutonomousFlag_get(rowreq_ctx,
 
738
                                               (u_long *) var->val.string);
 
739
        break;
 
740
 
 
741
        /*
 
742
         * ipAddressPrefixAdvPreferredLifetime(8)/UNSIGNED32/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/h 
 
743
         */
 
744
    case COLUMN_IPADDRESSPREFIXADVPREFERREDLIFETIME:
 
745
        var->val_len = sizeof(u_long);
 
746
        var->type = ASN_UNSIGNED;
 
747
        rc = ipAddressPrefixAdvPreferredLifetime_get(rowreq_ctx,
 
748
                                                     (u_long *) var->val.
 
749
                                                     string);
 
750
        break;
 
751
 
 
752
        /*
 
753
         * ipAddressPrefixAdvValidLifetime(9)/UNSIGNED32/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/h 
 
754
         */
 
755
    case COLUMN_IPADDRESSPREFIXADVVALIDLIFETIME:
 
756
        var->val_len = sizeof(u_long);
 
757
        var->type = ASN_UNSIGNED;
 
758
        rc = ipAddressPrefixAdvValidLifetime_get(rowreq_ctx,
 
759
                                                 (u_long *) var->val.
 
760
                                                 string);
 
761
        break;
 
762
 
 
763
    default:
 
764
        snmp_log(LOG_ERR,
 
765
                 "unknown column %d in _ipAddressPrefixTable_get_column\n",
 
766
                 column);
 
767
        break;
 
768
    }
 
769
 
 
770
    return rc;
 
771
}                               /* _ipAddressPrefixTable_get_column */
 
772
 
 
773
int
 
774
_mfd_ipAddressPrefixTable_get_values(netsnmp_mib_handler *handler,
 
775
                                     netsnmp_handler_registration *reginfo,
 
776
                                     netsnmp_agent_request_info
 
777
                                     *agtreq_info,
 
778
                                     netsnmp_request_info *requests)
 
779
{
 
780
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
 
781
        netsnmp_container_table_row_extract(requests);
 
782
    netsnmp_table_request_info *tri;
 
783
    u_char         *old_string;
 
784
    void            (*dataFreeHook) (void *);
 
785
    int             rc;
 
786
 
 
787
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_get_values", "called\n"));
 
788
 
 
789
    netsnmp_assert(NULL != rowreq_ctx);
 
790
 
 
791
    for (; requests; requests = requests->next) {
 
792
        /*
 
793
         * save old pointer, so we can free it if replaced
 
794
         */
 
795
        old_string = requests->requestvb->val.string;
 
796
        dataFreeHook = requests->requestvb->dataFreeHook;
 
797
        if (NULL == requests->requestvb->val.string) {
 
798
            requests->requestvb->val.string = requests->requestvb->buf;
 
799
            requests->requestvb->val_len =
 
800
                sizeof(requests->requestvb->buf);
 
801
        } else if (requests->requestvb->buf ==
 
802
                   requests->requestvb->val.string) {
 
803
            if (requests->requestvb->val_len !=
 
804
                sizeof(requests->requestvb->buf))
 
805
                requests->requestvb->val_len =
 
806
                    sizeof(requests->requestvb->buf);
 
807
        }
 
808
 
 
809
        /*
 
810
         * get column data
 
811
         */
 
812
        tri = netsnmp_extract_table_info(requests);
 
813
        if (NULL == tri)
 
814
            continue;
 
815
 
 
816
        rc = _ipAddressPrefixTable_get_column(rowreq_ctx,
 
817
                                              requests->requestvb,
 
818
                                              tri->colnum);
 
819
        if (rc) {
 
820
            if (MFD_SKIP == rc) {
 
821
                requests->requestvb->type = SNMP_NOSUCHINSTANCE;
 
822
                rc = SNMP_ERR_NOERROR;
 
823
            }
 
824
        } else if (NULL == requests->requestvb->val.string) {
 
825
            snmp_log(LOG_ERR, "NULL varbind data pointer!\n");
 
826
            rc = SNMP_ERR_GENERR;
 
827
        }
 
828
        if (rc)
 
829
            netsnmp_request_set_error(requests, SNMP_VALIDATE_ERR(rc));
 
830
 
 
831
        /*
 
832
         * if the buffer wasn't used previously for the old data (i.e. it
 
833
         * was allcoated memory)  and the get routine replaced the pointer,
 
834
         * we need to free the previous pointer.
 
835
         */
 
836
        if (old_string && (old_string != requests->requestvb->buf) &&
 
837
            (requests->requestvb->val.string != old_string)) {
 
838
            if (dataFreeHook)
 
839
                (*dataFreeHook) (old_string);
 
840
            else
 
841
                free(old_string);
 
842
        }
 
843
    }                           /* for results */
 
844
 
 
845
    return SNMP_ERR_NOERROR;
 
846
}                               /* _mfd_ipAddressPrefixTable_get_values */
 
847
 
 
848
 
 
849
/***********************************************************************
 
850
 *
 
851
 * SET processing
 
852
 *
 
853
 ***********************************************************************/
 
854
 
 
855
/*
 
856
 * SET PROCESSING NOT APPLICABLE (per MIB or user setting)
 
857
 */
 
858
/***********************************************************************
 
859
 *
 
860
 * DATA ACCESS
 
861
 *
 
862
 ***********************************************************************/
 
863
static void     _container_free(netsnmp_container *container);
 
864
 
 
865
/**
 
866
 * @internal
 
867
 */
 
868
static int
 
869
_cache_load(netsnmp_cache * cache, void *vmagic)
 
870
{
 
871
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_cache_load", "called\n"));
 
872
 
 
873
    if ((NULL == cache) || (NULL == cache->magic)) {
 
874
        snmp_log(LOG_ERR,
 
875
                 "invalid cache for ipAddressPrefixTable_cache_load\n");
 
876
        return -1;
 
877
    }
 
878
 
 
879
    /** should only be called for an invalid or expired cache */
 
880
    netsnmp_assert((0 == cache->valid) || (1 == cache->expired));
 
881
 
 
882
    /*
 
883
     * call user code
 
884
     */
 
885
    return ipAddressPrefixTable_container_load((netsnmp_container *)
 
886
                                               cache->magic);
 
887
}                               /* _cache_load */
 
888
 
 
889
/**
 
890
 * @internal
 
891
 */
 
892
static void
 
893
_cache_free(netsnmp_cache * cache, void *magic)
 
894
{
 
895
    netsnmp_container *container;
 
896
 
 
897
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_cache_free", "called\n"));
 
898
 
 
899
    if ((NULL == cache) || (NULL == cache->magic)) {
 
900
        snmp_log(LOG_ERR,
 
901
                 "invalid cache in ipAddressPrefixTable_cache_free\n");
 
902
        return;
 
903
    }
 
904
 
 
905
    container = (netsnmp_container *) cache->magic;
 
906
 
 
907
    _container_free(container);
 
908
}                               /* _cache_free */
 
909
 
 
910
/**
 
911
 * @internal
 
912
 */
 
913
static void
 
914
_container_item_free(ipAddressPrefixTable_rowreq_ctx * rowreq_ctx,
 
915
                     void *context)
 
916
{
 
917
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_container_item_free",
 
918
                "called\n"));
 
919
 
 
920
    if (NULL == rowreq_ctx)
 
921
        return;
 
922
 
 
923
    ipAddressPrefixTable_release_rowreq_ctx(rowreq_ctx);
 
924
}                               /* _container_item_free */
 
925
 
 
926
/**
 
927
 * @internal
 
928
 */
 
929
static void
 
930
_container_free(netsnmp_container *container)
 
931
{
 
932
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_container_free",
 
933
                "called\n"));
 
934
 
 
935
    if (NULL == container) {
 
936
        snmp_log(LOG_ERR,
 
937
                 "invalid container in ipAddressPrefixTable_container_free\n");
 
938
        return;
 
939
    }
 
940
 
 
941
    /*
 
942
     * call user code
 
943
     */
 
944
    ipAddressPrefixTable_container_free(container);
 
945
 
 
946
    /*
 
947
     * free all items. inefficient, but easy.
 
948
     */
 
949
    CONTAINER_CLEAR(container,
 
950
                    (netsnmp_container_obj_func *) _container_item_free,
 
951
                    NULL);
 
952
}                               /* _container_free */
 
953
 
 
954
/**
 
955
 * @internal
 
956
 * initialize the container with functions or wrappers
 
957
 */
 
958
void
 
959
_ipAddressPrefixTable_container_init(ipAddressPrefixTable_interface_ctx *
 
960
                                     if_ctx)
 
961
{
 
962
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_ipAddressPrefixTable_container_init", "called\n"));
 
963
 
 
964
    /*
 
965
     * cache init
 
966
     */
 
967
    if_ctx->cache = netsnmp_cache_create(30,    /* timeout in seconds */
 
968
                                         _cache_load, _cache_free,
 
969
                                         ipAddressPrefixTable_oid,
 
970
                                         ipAddressPrefixTable_oid_size);
 
971
 
 
972
    if (NULL == if_ctx->cache) {
 
973
        snmp_log(LOG_ERR,
 
974
                 "error creating cache for ipAddressPrefixTable\n");
 
975
        return;
 
976
    }
 
977
 
 
978
    if_ctx->cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
 
979
 
 
980
    ipAddressPrefixTable_container_init(&if_ctx->container, if_ctx->cache);
 
981
    if (NULL == if_ctx->container)
 
982
        if_ctx->container =
 
983
            netsnmp_container_find("ipAddressPrefixTable:table_container");
 
984
    if (NULL == if_ctx->container) {
 
985
        snmp_log(LOG_ERR, "error creating container in "
 
986
                 "ipAddressPrefixTable_container_init\n");
 
987
        return;
 
988
    }
 
989
 
 
990
    if (NULL != if_ctx->cache)
 
991
        if_ctx->cache->magic = (void *) if_ctx->container;
 
992
}                               /* _ipAddressPrefixTable_container_init */
 
993
 
 
994
/**
 
995
 * @internal
 
996
 * shutdown the container with functions or wrappers
 
997
 */
 
998
void
 
999
_ipAddressPrefixTable_container_shutdown(ipAddressPrefixTable_interface_ctx
 
1000
                                         * if_ctx)
 
1001
{
 
1002
    DEBUGMSGTL(("internal:ipAddressPrefixTable:_ipAddressPrefixTable_container_shutdown", "called\n"));
 
1003
 
 
1004
    ipAddressPrefixTable_container_shutdown(if_ctx->container);
 
1005
 
 
1006
    _container_free(if_ctx->container);
 
1007
 
 
1008
}                               /* _ipAddressPrefixTable_container_shutdown */
 
1009
 
 
1010
 
 
1011
ipAddressPrefixTable_rowreq_ctx *
 
1012
ipAddressPrefixTable_row_find_by_mib_index(ipAddressPrefixTable_mib_index *
 
1013
                                           mib_idx)
 
1014
{
 
1015
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx;
 
1016
    oid             oid_tmp[MAX_OID_LEN];
 
1017
    netsnmp_index   oid_idx;
 
1018
    int             rc;
 
1019
 
 
1020
    /*
 
1021
     * set up storage for OID
 
1022
     */
 
1023
    oid_idx.oids = oid_tmp;
 
1024
    oid_idx.len = sizeof(oid_tmp) / sizeof(oid);
 
1025
 
 
1026
    /*
 
1027
     * convert
 
1028
     */
 
1029
    rc = ipAddressPrefixTable_index_to_oid(&oid_idx, mib_idx);
 
1030
    if (MFD_SUCCESS != rc)
 
1031
        return NULL;
 
1032
 
 
1033
    rowreq_ctx =
 
1034
        CONTAINER_FIND(ipAddressPrefixTable_if_ctx.container, &oid_idx);
 
1035
 
 
1036
    return rowreq_ctx;
 
1037
}