pool/net-snmp
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f722276f7c
net-snmp/Add-IPv6-Scope-Zone-Index.patch

3482 lines
116 KiB
Diff
Raw Blame History

From 4d63cceb36d6a178aecd4a8e134b6eae795dfdab Mon Sep 17 00:00:00 2001
From: Mitsuru Chinen <mitch@linux.vnet.ibm.com>
Date: Mon, 20 Oct 2008 17:51:43 +0900
Subject: [PATCH] Add IPv6 Scope Zone Index
[ 1715405 ] Adding ipv6ScopeZoneIndexTable
http://sourceforge.net/tracker/index.php?func=detail&aid=1715405&group_id=12694&atid=312694
[ 1897883 ] Fix ipv6ScopeZoneIndexTable on Linux
http://sourceforge.net/tracker/index.php?func=detail&aid=1897883&group_id=12694&atid=312694
Signed-off-by: Mitsuru Chinen <mitch@linux.vnet.ibm.com>
---
agent/mibgroup/ip-mib/data_access/ipv6scopezone.h | 30 +
.../ip-mib/data_access/ipv6scopezone_common.c | 152 +++
.../ip-mib/data_access/ipv6scopezone_linux.c | 141 +++
agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable.h | 5 +
.../ipv6ScopeZoneIndexTable.c | 1004 +++++++++++++++++
.../ipv6ScopeZoneIndexTable.h | 269 +++++
.../ipv6ScopeZoneIndexTable_data_access.c | 304 ++++++
.../ipv6ScopeZoneIndexTable_data_access.h | 70 ++
.../ipv6ScopeZoneIndexTable_enums.h | 39 +
.../ipv6ScopeZoneIndexTable_interface.c | 1124 ++++++++++++++++++++
.../ipv6ScopeZoneIndexTable_interface.h | 98 ++
.../ipv6ScopeZoneIndexTable_oids.h | 55 +
include/net-snmp/data_access/scopezone.h | 68 ++
13 files changed, 3359 insertions(+), 0 deletions(-)
create mode 100644 agent/mibgroup/ip-mib/data_access/ipv6scopezone.h
create mode 100644 agent/mibgroup/ip-mib/data_access/ipv6scopezone_common.c
create mode 100644 agent/mibgroup/ip-mib/data_access/ipv6scopezone_linux.c
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable.h
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.c
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.h
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.c
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.h
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_enums.h
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.c
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.h
create mode 100644 agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_oids.h
create mode 100644 include/net-snmp/data_access/scopezone.h
diff --git a/agent/mibgroup/ip-mib/data_access/ipv6scopezone.h b/agent/mibgroup/ip-mib/data_access/ipv6scopezone.h
new file mode 100644
index 0000000..8d81b3f
--- /dev/null
+++ b/agent/mibgroup/ip-mib/data_access/ipv6scopezone.h
@@ -0,0 +1,30 @@
+/*
+ * scopezone data access header
+ *
+ * $Id: ipv6scopezone.h 14170 2007-04-29 02:22:12Z varun_c $
+ */
+/**---------------------------------------------------------------------*/
+/*
+ * configure required files
+ *
+ * Notes:
+ *
+ * 1) prefer functionality over platform, where possible. If a method
+ * is available for multiple platforms, test that first. That way
+ * when a new platform is ported, it won't need a new test here.
+ *
+ * 2) don't do detail requirements here. If, for example,
+ * HPUX11 had different reuirements than other HPUX, that should
+ * be handled in the *_hpux.h header file.
+ */
+config_require(ip-mib/data_access/ipv6scopezone_common)
+#if defined( linux )
+config_require(ip-mib/data_access/ipv6scopezone_linux)
+#else
+/*
+ * couldn't determine the correct file!
+ * require a bogus file to generate an error.
+ */
+config_require(ip-mib/data_access/ipv6scopezone-unknown-arch);
+#endif
+
diff --git a/agent/mibgroup/ip-mib/data_access/ipv6scopezone_common.c b/agent/mibgroup/ip-mib/data_access/ipv6scopezone_common.c
new file mode 100644
index 0000000..fdf712b
--- /dev/null
+++ b/agent/mibgroup/ip-mib/data_access/ipv6scopezone_common.c
@@ -0,0 +1,152 @@
+/*
+ * ipv6ScopeIndexTable MIB architecture support
+ *
+ * $Id: ipv6scopezone_common.c 14170 2007-04-29 02:22:12Z varun_c $
+ */
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+#include <net-snmp/data_access/scopezone.h>
+/*
+ * local static prototypes
+ */
+static void _entry_release(netsnmp_v6scopezone_entry * entry, void *unused);
+
+
+/**---------------------------------------------------------------------*/
+/*
+ * external per-architecture functions prototypes
+ *
+ * These shouldn't be called by the general public, so they aren't in
+ * the header file.
+ */
+extern int
+netsnmp_access_scopezone_container_arch_load(netsnmp_container* container,
+ u_int load_flags);
+extern void
+netsnmp_access_scopezone_arch_init(void);
+
+/**
+ * initialize systemstats container
+ */
+netsnmp_container *
+netsnmp_access_scopezone_container_init(u_int flags)
+{
+ netsnmp_container *container;
+
+ DEBUGMSGTL(("access:scopezone:container", "init\n"));
+ /*
+ * create the containers. one indexed by ifIndex, the other
+ * indexed by ifName.
+ */
+ container = netsnmp_container_find("access_scopezone:table_container");
+ if (NULL == container)
+ return NULL;
+
+ return container;
+}
+
+/**
+ * load scopezone information in specified container
+ *
+ * @param container empty container, or NULL to have one created for you
+ * @param load_flags flags to modify behaviour.
+ *
+ * @retval NULL error
+ * @retval !NULL pointer to container
+ */
+netsnmp_container*
+netsnmp_access_scopezone_container_load(netsnmp_container* container, u_int load_flags)
+{
+ int rc;
+
+ DEBUGMSGTL(("access:scopezone:container", "load\n"));
+
+ if (NULL == container)
+ container = netsnmp_access_scopezone_container_init(load_flags);
+ if (NULL == container) {
+ snmp_log(LOG_ERR, "no container specified/found for access_scopezone\n");
+ return NULL;
+ }
+
+ rc = netsnmp_access_scopezone_container_arch_load(container, load_flags);
+ if (0 != rc) {
+ netsnmp_access_scopezone_container_free(container,
+ NETSNMP_ACCESS_SCOPEZONE_FREE_NOFLAGS);
+ container = NULL;
+ }
+
+ return container;
+}
+
+void
+netsnmp_access_scopezone_container_free(netsnmp_container *container, u_int free_flags)
+{
+ DEBUGMSGTL(("access:scopezone:container", "free\n"));
+
+ if (NULL == container) {
+ snmp_log(LOG_ERR, "invalid container for netsnmp_access_scopezone_free\n");
+ return;
+ }
+
+ if(! (free_flags & NETSNMP_ACCESS_SCOPEZONE_FREE_DONT_CLEAR)) {
+ /*
+ * free all items.
+ */
+ CONTAINER_CLEAR(container,
+ (netsnmp_container_obj_func*)_entry_release,
+ NULL);
+ }
+
+ CONTAINER_FREE(container);
+}
+
+/**
+ */
+netsnmp_v6scopezone_entry *
+netsnmp_access_scopezone_entry_create(void)
+{
+ netsnmp_v6scopezone_entry *entry =
+ SNMP_MALLOC_TYPEDEF(netsnmp_v6scopezone_entry);
+
+ DEBUGMSGTL(("access:scopezone:entry", "create\n"));
+
+ if(NULL == entry)
+ return NULL;
+
+
+ entry->oid_index.len = 1;
+ entry->oid_index.oids = &entry->ns_scopezone_index;
+
+ return entry;
+}
+
+/**
+ */
+void
+netsnmp_access_scopezone_entry_free(netsnmp_v6scopezone_entry * entry)
+{
+ DEBUGMSGTL(("access:scopezone:entry", "free\n"));
+
+ if (NULL == entry)
+ return;
+
+
+ free(entry);
+}
+
+/**---------------------------------------------------------------------*/
+/*
+ * Utility routines
+ */
+
+/**
+ * \internal
+ */
+static void
+_entry_release(netsnmp_v6scopezone_entry * entry, void *context)
+{
+ netsnmp_access_scopezone_entry_free(entry);
+}
+
diff --git a/agent/mibgroup/ip-mib/data_access/ipv6scopezone_linux.c b/agent/mibgroup/ip-mib/data_access/ipv6scopezone_linux.c
new file mode 100644
index 0000000..d89f53c
--- /dev/null
+++ b/agent/mibgroup/ip-mib/data_access/ipv6scopezone_linux.c
@@ -0,0 +1,141 @@
+/*
+ * Interface MIB architecture support
+ *
+ * $Id: ipv6scopezone_linux.c 14170 2007-04-29 02:22:12Z varun_c $
+ */
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+#include <net-snmp/data_access/scopezone.h>
+
+#if defined (NETSNMP_ENABLE_IPV6)
+static int _scopezone_v6(netsnmp_container* container, int idx_offset);
+#endif
+
+/*
+ *
+ * @retval 0 success
+ * @retval -1 no container specified
+ * @retval -2 could not open file
+ * @retval -3 could not create entry (probably malloc)
+ * @retval -4 file format error
+ */
+int
+netsnmp_access_scopezone_container_arch_load(netsnmp_container* container,
+ u_int load_flags)
+{
+ int rc1 = 0, idx_offset = 0;
+#if defined (NETSNMP_ENABLE_IPV6)
+
+ if (NULL == container) {
+ snmp_log(LOG_ERR, "no container specified/found for access_scopezone_\n");
+ return -1;
+ }
+
+ rc1 = _scopezone_v6(container, idx_offset);
+#endif
+ if(rc1 > 0)
+ rc1 = 0;
+ return rc1;
+}
+
+#if defined (NETSNMP_ENABLE_IPV6)
+
+/* scope identifiers, from kernel - include/net/ipv6.h */
+#define IPV6_ADDR_LOOPBACK 0x0010U
+#define IPV6_ADDR_LINKLOCAL 0x0020U
+#define IPV6_ADDR_SITELOCAL 0x0040U
+
+static int
+_scopezone_v6(netsnmp_container* container, int idx_offset)
+{
+
+ /*
+ * On Linux, we support only link-local scope zones.
+ * Each interface, which has link-local address, gets unique scope
+ * zone index.
+ */
+ FILE *in;
+ char line[80], addr[40];
+ int if_index, pfx_len, scope, flags, rc = 0;
+ int last_if_index = -1;
+ netsnmp_v6scopezone_entry *entry;
+ static int log_open_err = 1;
+
+ netsnmp_assert(NULL != container);
+
+#define PROCFILE "/proc/net/if_inet6"
+ if (!(in = fopen(PROCFILE, "r"))) {
+ if (1 == log_open_err) {
+ snmp_log(LOG_ERR,"could not open " PROCFILE "\n");
+ log_open_err = 0;
+ }
+ return -2;
+ }
+ /*
+ * if we hadn't been able to open file and turned of err logging,
+ * turn it back on now that we opened the file.
+ */
+ if (0 == log_open_err)
+ log_open_err = 1;
+
+ /*
+ * address index prefix_len scope status if_name
+ */
+ while (fgets(line, sizeof(line), in)) {
+ /*
+ * fe800000000000000200e8fffe5b5c93 05 40 20 80 eth0
+ * A D P S F I
+ * A: address
+ * D: device number
+ * P: prefix len
+ * S: scope (see include/net/ipv6.h, net/ipv6/addrconf.c)
+ * F: flags (see include/linux/rtnetlink.h, net/ipv6/addrconf.c)
+ * I: interface
+ */
+ rc = sscanf(line, "%39s %02x %02x %02x %02x\n",
+ addr, &if_index, &pfx_len, &scope, &flags);
+ if( 5 != rc ) {
+ snmp_log(LOG_ERR, PROCFILE " data format error (%d!=5), line ==|%s|\n",
+ rc, line);
+ continue;
+ }
+ DEBUGMSGTL(("access:scopezone:container",
+ "addr %s, index %d, pfx %d, scope %d, flags 0x%X\n",
+ addr, if_index, pfx_len, scope, flags));
+
+ if (! (scope & IPV6_ADDR_LINKLOCAL)) {
+ DEBUGMSGTL(("access:scopezone:container",
+ "The address is not link-local, skipping\n"));
+ continue;
+ }
+ /*
+ * Check that the interface was not inserted before, just in case
+ * one interface has two or more link-local addresses.
+ */
+ if (last_if_index == if_index) {
+ DEBUGMSGTL(("access:scopezone:container",
+ "The interface was already inserted, skipping\n"));
+ continue;
+ }
+
+ last_if_index = if_index;
+ entry = netsnmp_access_scopezone_entry_create();
+ if(NULL == entry) {
+ rc = -3;
+ break;
+ }
+ entry->ns_scopezone_index = ++idx_offset;
+ entry->index = if_index;
+ entry->scopezone_linklocal = if_index;
+
+ CONTAINER_INSERT(container, entry);
+ }
+ fclose(in);
+ if(rc<0)
+ return rc;
+
+ return idx_offset;
+}
+#endif
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable.h b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable.h
new file mode 100644
index 0000000..779bd75
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable.h
@@ -0,0 +1,5 @@
+/*
+ * module to include the modules
+ */
+
+config_require(ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable)
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.c b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.c
new file mode 100644
index 0000000..edd6586
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.c
@@ -0,0 +1,1004 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * version : 14170 $ of $
+ *
+ * $Id:ipv6ScopeZoneIndexTable.c 14170 2007-04-29 00:12:32Z varun_c$
+ */
+/** \page MFD helper for ipv6ScopeZoneIndexTable
+ *
+ * \section intro Introduction
+ * Introductory text.
+ *
+ */
+/*
+ * standard Net-SNMP includes
+ */
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+/*
+ * include our parent header
+ */
+#include "ipv6ScopeZoneIndexTable.h"
+
+#include <net-snmp/agent/mib_modules.h>
+
+#include "ipv6ScopeZoneIndexTable_interface.h"
+
+oid ipv6ScopeZoneIndexTable_oid[] =
+ { IPV6SCOPEZONEINDEXTABLE_OID };
+int ipv6ScopeZoneIndexTable_oid_size =
+OID_LENGTH(ipv6ScopeZoneIndexTable_oid);
+
+ipv6ScopeZoneIndexTable_registration ipv6ScopeZoneIndexTable_user_context;
+
+void initialize_table_ipv6ScopeZoneIndexTable(void);
+void shutdown_table_ipv6ScopeZoneIndexTable(void);
+
+
+/**
+ * Initializes the ipv6ScopeZoneIndexTable module
+ */
+void
+init_ipv6ScopeZoneIndexTable(void)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:init_ipv6ScopeZoneIndexTable", "called\n"));
+
+ /*
+ * TODO:300:o: Perform ipv6ScopeZoneIndexTable one-time module initialization.
+ */
+
+ /*
+ * here we initialize all the tables we're planning on supporting
+ */
+ if (should_init("ipv6ScopeZoneIndexTable"))
+ initialize_table_ipv6ScopeZoneIndexTable();
+
+} /* init_ipv6ScopeZoneIndexTable */
+
+/**
+ * Shut-down the ipv6ScopeZoneIndexTable module (agent is exiting)
+ */
+void
+shutdown_ipv6ScopeZoneIndexTable(void)
+{
+ if (should_init("ipv6ScopeZoneIndexTable"))
+ shutdown_table_ipv6ScopeZoneIndexTable();
+
+}
+
+/**
+ * Initialize the table ipv6ScopeZoneIndexTable
+ * (Define its contents and how it's structured)
+ */
+void
+initialize_table_ipv6ScopeZoneIndexTable(void)
+{
+ ipv6ScopeZoneIndexTable_registration *user_context;
+ u_long flags;
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:initialize_table_ipv6ScopeZoneIndexTable", "called\n"));
+
+ /*
+ * TODO:301:o: Perform ipv6ScopeZoneIndexTable one-time table initialization.
+ */
+
+ /*
+ * TODO:302:o: |->Initialize ipv6ScopeZoneIndexTable user context
+ * if you'd like to pass in a pointer to some data for this
+ * table, allocate or set it up here.
+ */
+ /*
+ * a netsnmp_data_list is a simple way to store void pointers. A simple
+ * string token is used to add, find or remove pointers.
+ */
+ user_context =
+ netsnmp_create_data_list("ipv6ScopeZoneIndexTable", NULL, NULL);
+
+ /*
+ * No support for any flags yet, but in the future you would
+ * set any flags here.
+ */
+ flags = 0;
+
+ /*
+ * call interface initialization code
+ */
+ _ipv6ScopeZoneIndexTable_initialize_interface(user_context, flags);
+} /* initialize_table_ipv6ScopeZoneIndexTable */
+
+/**
+ * Shutdown the table ipv6ScopeZoneIndexTable
+ */
+void
+shutdown_table_ipv6ScopeZoneIndexTable(void)
+{
+ /*
+ * call interface shutdown code
+ */
+ _ipv6ScopeZoneIndexTable_shutdown_interface
+ (&ipv6ScopeZoneIndexTable_user_context);
+}
+
+/**
+ * extra context initialization (eg default values)
+ *
+ * @param rowreq_ctx : row request context
+ * @param user_init_ctx : void pointer for user (parameter to rowreq_ctx_allocate)
+ *
+ * @retval MFD_SUCCESS : no errors
+ * @retval MFD_ERROR : error (context allocate will fail)
+ */
+int
+ipv6ScopeZoneIndexTable_rowreq_ctx_init(ipv6ScopeZoneIndexTable_rowreq_ctx
+ * rowreq_ctx, void *user_init_ctx)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_rowreq_ctx_init", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:210:o: |-> Perform extra ipv6ScopeZoneIndexTable rowreq initialization. (eg DEFVALS)
+ */
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_rowreq_ctx_init */
+
+/**
+ * extra context cleanup
+ *
+ */
+void
+ipv6ScopeZoneIndexTable_rowreq_ctx_cleanup
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_rowreq_ctx_cleanup", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:211:o: |-> Perform extra ipv6ScopeZoneIndexTable rowreq cleanup.
+ */
+} /* ipv6ScopeZoneIndexTable_rowreq_ctx_cleanup */
+
+/**
+ * pre-request callback
+ *
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_ERROR : other error
+ */
+int
+ipv6ScopeZoneIndexTable_pre_request(ipv6ScopeZoneIndexTable_registration *
+ user_context)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_pre_request", "called\n"));
+
+ /*
+ * TODO:510:o: Perform ipv6ScopeZoneIndexTable pre-request actions.
+ */
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_pre_request */
+
+/**
+ * post-request callback
+ *
+ * Note:
+ * New rows have been inserted into the container, and
+ * deleted rows have been removed from the container and
+ * released.
+ *
+ * @param user_context
+ * @param rc : MFD_SUCCESS if all requests succeeded
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_ERROR : other error (ignored)
+ */
+int
+ipv6ScopeZoneIndexTable_post_request(ipv6ScopeZoneIndexTable_registration *
+ user_context, int rc)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_post_request", "called\n"));
+
+ /*
+ * TODO:511:o: Perform ipv6ScopeZoneIndexTable post-request actions.
+ */
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_post_request */
+
+/*
+ * ipv6ScopeZoneIndexTable_allocate_data
+ *
+ * Purpose: create new ipv6ScopeZoneIndexTable_data.
+ */
+ipv6ScopeZoneIndexTable_data *
+ipv6ScopeZoneIndexTable_allocate_data(void)
+{
+ /*
+ * TODO:201:r: |-> allocate memory for the ipv6ScopeZoneIndexTable data context.
+ */
+ ipv6ScopeZoneIndexTable_data *rtn = netsnmp_access_scopezone_entry_create();
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_allocate_data", "called\n"));
+
+ if (NULL == rtn) {
+ snmp_log(LOG_ERR, "unable to malloc memory for new "
+ "ipv6ScopeZoneIndexTable_data.\n");
+ }
+
+ return rtn;
+} /* ipv6ScopeZoneIndexTable_allocate_data */
+
+/*
+ * ipv6ScopeZoneIndexTable_release_data
+ *
+ * Purpose: release ipv6ScopeZoneIndexTable data.
+ */
+void
+ipv6ScopeZoneIndexTable_release_data(ipv6ScopeZoneIndexTable_data * data)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_release_data", "called\n"));
+
+ /*
+ * TODO:202:r: |-> release memory for the ipv6ScopeZoneIndexTable data context.
+ */
+ netsnmp_access_scopezone_entry_free(data);
+} /* ipv6ScopeZoneIndexTable_release_data */
+
+/** @defgroup data_get data_get: Routines to get data
+ *
+ * TODO:230:M: Implement ipv6ScopeZoneIndexTable get routines.
+ * TODO:240:M: Implement ipv6ScopeZoneIndexTable mapping routines (if any).
+ *
+ * These routine are used to get the value for individual objects. The
+ * row context is passed, along with a pointer to the memory where the
+ * value should be copied.
+ *
+ * @{
+ */
+/**********************************************************************
+ **********************************************************************
+ ***
+ *** Table ipv6ScopeZoneIndexTable
+ ***
+ **********************************************************************
+ **********************************************************************/
+/*
+ * IP-MIB::ipv6ScopeZoneIndexTable is subid 36 of ip.
+ * Its status is Current.
+ * OID: .1.3.6.1.2.1.4.36, length: 8
+ */
+
+/*
+ * ---------------------------------------------------------------------
+ * * TODO:200:r: Implement ipv6ScopeZoneIndexTable data context functions.
+ */
+
+
+/**
+ * set mib index(es)
+ *
+ * @param tbl_idx mib index structure
+ * @param ipv6ScopeZoneIndexIfIndex_val
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_ERROR : other error.
+ *
+ * @remark
+ * This convenience function is useful for setting all the MIB index
+ * components with a single function call. It is assume that the C values
+ * have already been mapped from their native/rawformat to the MIB format.
+ */
+int
+ipv6ScopeZoneIndexTable_indexes_set_tbl_idx
+ (ipv6ScopeZoneIndexTable_mib_index * tbl_idx,
+ long ipv6ScopeZoneIndexIfIndex_val)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_indexes_set_tbl_idx", "called\n"));
+
+ /*
+ * ipv6ScopeZoneIndexIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
+ */
+ tbl_idx->ipv6ScopeZoneIndexIfIndex = ipv6ScopeZoneIndexIfIndex_val;
+
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_indexes_set_tbl_idx */
+
+/**
+ * @internal
+ * set row context indexes
+ *
+ * @param reqreq_ctx the row context that needs updated indexes
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_ERROR : other error.
+ *
+ * @remark
+ * This function sets the mib indexs, then updates the oid indexs
+ * from the mib index.
+ */
+int
+ipv6ScopeZoneIndexTable_indexes_set(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ long ipv6ScopeZoneIndexIfIndex_val)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_indexes_set", "called\n"));
+
+ if (MFD_SUCCESS !=
+ ipv6ScopeZoneIndexTable_indexes_set_tbl_idx(&rowreq_ctx->tbl_idx,
+ ipv6ScopeZoneIndexIfIndex_val))
+ return MFD_ERROR;
+
+ /*
+ * convert mib index to oid index
+ */
+ rowreq_ctx->oid_idx.len = sizeof(rowreq_ctx->oid_tmp) / sizeof(oid);
+ if (0 != ipv6ScopeZoneIndexTable_index_to_oid(&rowreq_ctx->oid_idx,
+ &rowreq_ctx->tbl_idx)) {
+ return MFD_ERROR;
+ }
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_indexes_set */
+
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexLinkLocal
+ * ipv6ScopeZoneIndexLinkLocal is subid 2 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.2
+ * Description:
+The zone index for the link-local scope on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexLinkLocal data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexLinkLocal_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexLinkLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexLinkLocal_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexLinkLocal_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexLinkLocal_get", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexLinkLocal data.
+ * copy (* ipv6ScopeZoneIndexLinkLocal_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexLinkLocal_val_ptr) =
+ rowreq_ctx->data->scopezone_linklocal;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexLinkLocal_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndex3
+ * ipv6ScopeZoneIndex3 is subid 3 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.3
+ * Description:
+The zone index for scope 3 on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndex3 data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndex3_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndex3_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex3_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndex3_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndex3_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndex3 data.
+ * copy (* ipv6ScopeZoneIndex3_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndex3_val_ptr) = 0;
+
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndex3_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexAdminLocal
+ * ipv6ScopeZoneIndexAdminLocal is subid 4 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.4
+ * Description:
+The zone index for the admin-local scope on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexAdminLocal data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexAdminLocal_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexAdminLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexAdminLocal_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexAdminLocal_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexAdminLocal_get", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexAdminLocal data.
+ * copy (* ipv6ScopeZoneIndexAdminLocal_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexAdminLocal_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexAdminLocal_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexSiteLocal
+ * ipv6ScopeZoneIndexSiteLocal is subid 5 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.5
+ * Description:
+The zone index for the site-local scope on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexSiteLocal data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexSiteLocal_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexSiteLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexSiteLocal_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexSiteLocal_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexSiteLocal_get", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexSiteLocal data.
+ * copy (* ipv6ScopeZoneIndexSiteLocal_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexSiteLocal_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexSiteLocal_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndex6
+ * ipv6ScopeZoneIndex6 is subid 6 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.6
+ * Description:
+The zone index for scope 6 on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndex6 data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndex6_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndex6_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex6_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndex6_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndex6_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndex6 data.
+ * copy (* ipv6ScopeZoneIndex6_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndex6_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndex6_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndex7
+ * ipv6ScopeZoneIndex7 is subid 7 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.7
+ * Description:
+The zone index for scope 7 on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndex7 data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndex7_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndex7_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex7_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndex7_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndex7_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndex7 data.
+ * copy (* ipv6ScopeZoneIndex7_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndex7_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndex7_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexOrganizationLocal
+ * ipv6ScopeZoneIndexOrganizationLocal is subid 8 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.8
+ * Description:
+The zone index for the organization-local scope on this
+ interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexOrganizationLocal data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexOrganizationLocal_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexOrganizationLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx
+ * rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexOrganizationLocal_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexOrganizationLocal_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexOrganizationLocal_get", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexOrganizationLocal data.
+ * copy (* ipv6ScopeZoneIndexOrganizationLocal_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexOrganizationLocal_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexOrganizationLocal_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndex9
+ * ipv6ScopeZoneIndex9 is subid 9 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.9
+ * Description:
+The zone index for scope 9 on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndex9 data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndex9_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndex9_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex9_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndex9_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndex9_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndex9 data.
+ * copy (* ipv6ScopeZoneIndex9_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndex9_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndex9_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexA
+ * ipv6ScopeZoneIndexA is subid 10 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.10
+ * Description:
+The zone index for scope A on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexA data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexA_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexA_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexA_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexA_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexA_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexA data.
+ * copy (* ipv6ScopeZoneIndexA_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexA_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexA_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexB
+ * ipv6ScopeZoneIndexB is subid 11 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.11
+ * Description:
+The zone index for scope B on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexB data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexB_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexB_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexB_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexB_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexB_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexB data.
+ * copy (* ipv6ScopeZoneIndexB_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexB_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexB_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexC
+ * ipv6ScopeZoneIndexC is subid 12 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.12
+ * Description:
+The zone index for scope C on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexC data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexC_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexC_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexC_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexC_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexC_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexC data.
+ * copy (* ipv6ScopeZoneIndexC_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexC_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexC_get */
+
+/*---------------------------------------------------------------------
+ * IP-MIB::ipv6ScopeZoneIndexEntry.ipv6ScopeZoneIndexD
+ * ipv6ScopeZoneIndexD is subid 13 of ipv6ScopeZoneIndexEntry.
+ * Its status is Current, and its access level is ReadOnly.
+ * OID: .1.3.6.1.2.1.4.36.1.13
+ * Description:
+The zone index for scope D on this interface.
+ *
+ * Attributes:
+ * accessible 1 isscalar 0 enums 0 hasdefval 0
+ * readable 1 iscolumn 1 ranges 0 hashint 1
+ * settable 0
+ * hint: d
+ *
+ *
+ * Its syntax is InetZoneIndex (based on perltype UNSIGNED32)
+ * The net-snmp type is ASN_UNSIGNED. The C type decl is u_long (u_long)
+ */
+/**
+ * Extract the current value of the ipv6ScopeZoneIndexD data.
+ *
+ * Set a value using the data context for the row.
+ *
+ * @param rowreq_ctx
+ * Pointer to the row request context.
+ * @param ipv6ScopeZoneIndexD_val_ptr
+ * Pointer to storage for a u_long variable
+ *
+ * @retval MFD_SUCCESS : success
+ * @retval MFD_SKIP : skip this node (no value for now)
+ * @retval MFD_ERROR : Any other error
+ */
+int
+ipv6ScopeZoneIndexD_get(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexD_val_ptr)
+{
+ /** we should have a non-NULL pointer */
+ netsnmp_assert(NULL != ipv6ScopeZoneIndexD_val_ptr);
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexD_get",
+ "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:231:o: |-> Extract the current value of the ipv6ScopeZoneIndexD data.
+ * copy (* ipv6ScopeZoneIndexD_val_ptr ) from rowreq_ctx->data
+ */
+ (*ipv6ScopeZoneIndexD_val_ptr) = 0;
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexD_get */
+
+
+/** @{ */
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.h b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.h
new file mode 100644
index 0000000..bced5af
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable.h
@@ -0,0 +1,269 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * version : 14170 $ of $
+ *
+ * $Id:ipv6ScopeZoneIndexTable.h 14170 2007-04-29 00:12:32Z varun_c$
+ */
+#ifndef IPV6SCOPEZONEINDEXTABLE_H
+#define IPV6SCOPEZONEINDEXTABLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @addtogroup misc misc: Miscellaneous routines
+ *
+ * @{
+ */
+#include <net-snmp/library/asn1.h>
+#include <net-snmp/data_access/scopezone.h>
+ /*
+ * other required module components
+ */
+ /* *INDENT-OFF* */
+config_require(ip-mib/data_access/ipv6scopezone)
+config_require(ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface)
+config_require(ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access)
+ /* *INDENT-ON* */
+
+ /*
+ * OID and column number definitions for ipv6ScopeZoneIndexTable
+ */
+#include "ipv6ScopeZoneIndexTable_oids.h"
+
+ /*
+ * enum definions
+ */
+#include "ipv6ScopeZoneIndexTable_enums.h"
+
+ /*
+ *********************************************************************
+ * function declarations
+ */
+ void init_ipv6ScopeZoneIndexTable(void);
+ void shutdown_ipv6ScopeZoneIndexTable(void);
+
+ /*
+ *********************************************************************
+ * Table declarations
+ */
+/**********************************************************************
+ **********************************************************************
+ ***
+ *** Table ipv6ScopeZoneIndexTable
+ ***
+ **********************************************************************
+ **********************************************************************/
+ /*
+ * IP-MIB::ipv6ScopeZoneIndexTable is subid 36 of ip.
+ * Its status is Current.
+ * OID: .1.3.6.1.2.1.4.36, length: 8
+ */
+ /*
+ *********************************************************************
+ * When you register your mib, you get to provide a generic
+ * pointer that will be passed back to you for most of the
+ * functions calls.
+ *
+ * TODO:100:r: Review all context structures
+ */
+ /*
+ * TODO:101:o: |-> Review ipv6ScopeZoneIndexTable registration context.
+ */
+ typedef netsnmp_data_list ipv6ScopeZoneIndexTable_registration;
+/**********************************************************************/
+ /*
+ * TODO:110:r: |-> Review ipv6ScopeZoneTable data context structure.
+ * This structure is used to represent the data for ipv6ScopeZoneTable.
+ */
+ typedef netsnmp_v6scopezone_entry ipv6ScopeZoneIndexTable_data;
+
+
+ /*
+ * TODO:120:r: |-> Review ipv6ScopeZoneIndexTable mib index.
+ * This structure is used to represent the index for ipv6ScopeZoneIndexTable.
+ */
+ typedef struct ipv6ScopeZoneIndexTable_mib_index_s {
+
+ /*
+ * ipv6ScopeZoneIndexIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
+ */
+ long ipv6ScopeZoneIndexIfIndex;
+
+
+ } ipv6ScopeZoneIndexTable_mib_index;
+
+ /*
+ * TODO:121:r: | |-> Review ipv6ScopeZoneIndexTable max index length.
+ * If you KNOW that your indexes will never exceed a certain
+ * length, update this macro to that length.
+ */
+#define MAX_ipv6ScopeZoneIndexTable_IDX_LEN 1
+
+ /*
+ *********************************************************************
+ * TODO:130:o: |-> Review ipv6ScopeZoneIndexTable Row request (rowreq) context.
+ * When your functions are called, you will be passed a
+ * ipv6ScopeZoneIndexTable_rowreq_ctx pointer.
+ */
+ typedef struct ipv6ScopeZoneIndexTable_rowreq_ctx_s {
+
+ /** this must be first for container compare to work */
+ netsnmp_index oid_idx;
+ oid oid_tmp[MAX_ipv6ScopeZoneIndexTable_IDX_LEN];
+
+ ipv6ScopeZoneIndexTable_mib_index tbl_idx;
+
+ ipv6ScopeZoneIndexTable_data *data;
+
+ /*
+ * flags per row. Currently, the first (lower) 8 bits are reserved
+ * for the user. See mfd.h for other flags.
+ */
+ u_int rowreq_flags;
+
+ /*
+ * TODO:131:o: | |-> Add useful data to ipv6ScopeZoneIndexTable rowreq context.
+ */
+
+ /*
+ * storage for future expansion
+ */
+ netsnmp_data_list *ipv6ScopeZoneIndexTable_data_list;
+
+ } ipv6ScopeZoneIndexTable_rowreq_ctx;
+
+ typedef struct ipv6ScopeZoneIndexTable_ref_rowreq_ctx_s {
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx;
+ } ipv6ScopeZoneIndexTable_ref_rowreq_ctx;
+
+ /*
+ *********************************************************************
+ * function prototypes
+ */
+ int
+ ipv6ScopeZoneIndexTable_pre_request
+ (ipv6ScopeZoneIndexTable_registration * user_context);
+ int
+ ipv6ScopeZoneIndexTable_post_request
+ (ipv6ScopeZoneIndexTable_registration * user_context, int rc);
+
+ int
+ ipv6ScopeZoneIndexTable_rowreq_ctx_init
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ void *user_init_ctx);
+ void
+ ipv6ScopeZoneIndexTable_rowreq_ctx_cleanup
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx);
+
+
+ ipv6ScopeZoneIndexTable_rowreq_ctx
+ *ipv6ScopeZoneIndexTable_row_find_by_mib_index
+ (ipv6ScopeZoneIndexTable_mib_index * mib_idx);
+
+ ipv6ScopeZoneIndexTable_data *
+ ipv6ScopeZoneIndexTable_allocate_data(void);
+
+ void
+ ipv6ScopeZoneIndexTable_release_data(ipv6ScopeZoneIndexTable_data * data);
+
+ extern oid ipv6ScopeZoneIndexTable_oid[];
+ extern int ipv6ScopeZoneIndexTable_oid_size;
+
+
+#include "ipv6ScopeZoneIndexTable_interface.h"
+#include "ipv6ScopeZoneIndexTable_data_access.h"
+/**********************************************************************
+ **********************************************************************
+ ***
+ *** Table ipv6ScopeZoneIndexTable
+ ***
+ **********************************************************************
+ **********************************************************************/
+ /*
+ * IP-MIB::ipv6ScopeZoneIndexTable is subid 36 of ip.
+ * Its status is Current.
+ * OID: .1.3.6.1.2.1.4.36, length: 8
+ */
+ /*
+ * indexes
+ */
+
+ int
+ ipv6ScopeZoneIndexLinkLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx
+ * rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexLinkLocal_val_ptr);
+ int
+ ipv6ScopeZoneIndex3_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex3_val_ptr);
+ int
+ ipv6ScopeZoneIndexAdminLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx
+ * rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexAdminLocal_val_ptr);
+ int
+ ipv6ScopeZoneIndexSiteLocal_get(ipv6ScopeZoneIndexTable_rowreq_ctx
+ * rowreq_ctx,
+ u_long *
+ ipv6ScopeZoneIndexSiteLocal_val_ptr);
+ int
+ ipv6ScopeZoneIndex6_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex6_val_ptr);
+ int
+ ipv6ScopeZoneIndex7_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex7_val_ptr);
+ int
+ ipv6ScopeZoneIndexOrganizationLocal_get
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexOrganizationLocal_val_ptr);
+ int
+ ipv6ScopeZoneIndex9_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndex9_val_ptr);
+ int
+ ipv6ScopeZoneIndexA_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexA_val_ptr);
+ int
+ ipv6ScopeZoneIndexB_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexB_val_ptr);
+ int
+ ipv6ScopeZoneIndexC_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexC_val_ptr);
+ int
+ ipv6ScopeZoneIndexD_get(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ u_long * ipv6ScopeZoneIndexD_val_ptr);
+
+
+ int
+ ipv6ScopeZoneIndexTable_indexes_set_tbl_idx
+ (ipv6ScopeZoneIndexTable_mib_index * tbl_idx,
+ long ipv6ScopeZoneIndexIfIndex_val);
+ int
+ ipv6ScopeZoneIndexTable_indexes_set
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ long ipv6ScopeZoneIndexIfIndex_val);
+
+ /*
+ * DUMMY markers, ignore
+ *
+ * TODO:099:x: *************************************************************
+ * TODO:199:x: *************************************************************
+ * TODO:299:x: *************************************************************
+ * TODO:399:x: *************************************************************
+ * TODO:499:x: *************************************************************
+ */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* IPV6SCOPEZONEINDEXTABLE_H */
+/** @} */
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.c b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.c
new file mode 100644
index 0000000..7105dbf
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.c
@@ -0,0 +1,304 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * version : 14170 $ of $
+ *
+ * $Id:ipv6ScopeZoneIndexTable_data_access.c 14170 2007-04-29 00:12:32Z varun_c$
+ */
+/*
+ * standard Net-SNMP includes
+ */
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+/*
+ * include our parent header
+ */
+#include "ipv6ScopeZoneIndexTable.h"
+
+
+#include "ipv6ScopeZoneIndexTable_data_access.h"
+
+/** @ingroup interface
+ * @addtogroup data_access data_access: Routines to access data
+ *
+ * These routines are used to locate the data used to satisfy
+ * requests.
+ *
+ * @{
+ */
+/**********************************************************************
+ **********************************************************************
+ ***
+ *** Table ipv6ScopeZoneIndexTable
+ ***
+ **********************************************************************
+ **********************************************************************/
+/*
+ * IP-MIB::ipv6ScopeZoneIndexTable is subid 36 of ip.
+ * Its status is Current.
+ * OID: .1.3.6.1.2.1.4.36, length: 8
+ */
+
+/**
+ * initialization for ipv6ScopeZoneIndexTable data access
+ *
+ * This function is called during startup to allow you to
+ * allocate any resources you need for the data table.
+ *
+ * @param ipv6ScopeZoneIndexTable_reg
+ * Pointer to ipv6ScopeZoneIndexTable_registration
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_ERROR : unrecoverable error.
+ */
+int
+ipv6ScopeZoneIndexTable_init_data(ipv6ScopeZoneIndexTable_registration *
+ ipv6ScopeZoneIndexTable_reg)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_init_data", "called\n"));
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_init_data */
+
+/**
+ * container overview
+ *
+ */
+
+/**
+ * container initialization
+ *
+ * @param container_ptr_ptr A pointer to a container pointer. If you
+ * create a custom container, use this parameter to return it
+ * to the MFD helper. If set to NULL, the MFD helper will
+ * allocate a container for you.
+ *
+ * This function is called at startup to allow you to customize certain
+ * aspects of the access method. For the most part, it is for advanced
+ * users. The default code should suffice for most cases. If no custom
+ * container is allocated, the MFD code will create one for your.
+ *
+ * @remark
+ * This would also be a good place to do any initialization needed
+ * for you data source. For example, opening a connection to another
+ * process that will supply the data, opening a database, etc.
+ */
+void
+ipv6ScopeZoneIndexTable_container_init(netsnmp_container **
+ container_ptr_ptr,
+ netsnmp_cache * cache)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_container_init", "called\n"));
+
+ if (NULL == container_ptr_ptr) {
+ snmp_log(LOG_ERR,
+ "bad container param to ipv6ScopeZoneIndexTable_container_init\n");
+ return;
+ }
+
+ /*
+ * For advanced users, you can use a custom container. If you
+ * do not create one, one will be created for you.
+ */
+ *container_ptr_ptr = NULL;
+ if (NULL == cache) {
+ snmp_log(LOG_ERR,
+ "bad cache param to ipv6ScopeZoneIndexTable_container_init\n");
+ return;
+ }
+
+ /*
+ * TODO:345:A: Set up ipv6ScopeZoneIndexTable cache properties.
+ *
+ * Also for advanced users, you can set parameters for the
+ * cache. Do not change the magic pointer, as it is used
+ * by the MFD helper. To completely disable caching, set
+ * cache->enabled to 0.
+ */
+ cache->timeout = 60; /* seconds */
+
+
+} /* ipv6ScopeZoneIndexTable_container_init */
+
+/**
+ * container shutdown
+ *
+ * @param container_ptr A pointer to the container.
+ *
+ * This function is called at shutdown to allow you to customize certain
+ * aspects of the access method. For the most part, it is for advanced
+ * users. The default code should suffice for most cases.
+ *
+ * This function is called before ipv6ScopeZoneIndexTable_container_free().
+ *
+ * @remark
+ * This would also be a good place to do any cleanup needed
+ * for you data source. For example, closing a connection to another
+ * process that supplied the data, closing a database, etc.
+ */
+void
+ipv6ScopeZoneIndexTable_container_shutdown(netsnmp_container *container_ptr)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_container_shutdown", "called\n"));
+
+ if (NULL == container_ptr) {
+ snmp_log(LOG_ERR,
+ "bad params to ipv6ScopeZoneIndexTable_container_shutdown\n");
+ return;
+ }
+
+} /* ipv6ScopeZoneIndexTable_container_shutdown */
+
+/**
+ * check entry for update
+ *
+ */
+static void
+_snarf_zoneindex_entry(netsnmp_v6scopezone_entry *scopezone_entry,
+ netsnmp_container *container)
+{
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx;
+
+ DEBUGTRACE;
+ netsnmp_assert(NULL != scopezone_entry);
+ netsnmp_assert(NULL != container);
+ rowreq_ctx = ipv6ScopeZoneIndexTable_allocate_rowreq_ctx(scopezone_entry,NULL);
+ if ((NULL != rowreq_ctx) &&
+ (MFD_SUCCESS == ipv6ScopeZoneIndexTable_indexes_set
+ (rowreq_ctx, rowreq_ctx->data->index))) {
+ CONTAINER_INSERT(container, rowreq_ctx);
+ } else {
+ if (rowreq_ctx) {
+ snmp_log(LOG_ERR, "error setting index while loading "
+ "ipv6ScopeZoneIndexTable cache.\n");
+ ipv6ScopeZoneIndexTable_release_rowreq_ctx(rowreq_ctx);
+ } else
+ netsnmp_access_scopezone_entry_free(scopezone_entry);
+ }
+
+}
+
+/**
+ * load initial data
+ *
+ * TODO:350:M: Implement ipv6ScopeZoneIndexTable data load
+ *
+ * @param container container to which items should be inserted
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source
+ * @retval MFD_ERROR : other error.
+ *
+ * This function is called to load the index(es) (and data, optionally)
+ * for the every row in the data set.
+ *
+ * @remark
+ * While loading the data, the only important thing is the indexes.
+ * If access to your data is cheap/fast (e.g. you have a pointer to a
+ * structure in memory), it would make sense to update the data here.
+ * If, however, the accessing the data invovles more work (e.g. parsing
+ * some other existing data, or peforming calculations to derive the data),
+ * then you can limit yourself to setting the indexes and saving any
+ * information you will need later. Then use the saved information in
+ * ipv6ScopeZoneIndexTable_row_prep() for populating data.
+ *
+ * @note
+ * If you need consistency between rows (like you want statistics
+ * for each row to be from the same time frame), you should set all
+ * data here.
+ *
+ */
+int
+ipv6ScopeZoneIndexTable_container_load(netsnmp_container * container)
+{
+
+ /*
+ * temporary storage for index values
+ */
+ /*
+ * ipv6ScopeZoneIndexIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
+ */
+ netsnmp_container *zoneindex = netsnmp_access_scopezone_container_load(NULL, 0);
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_container_load", "called\n"));
+
+ if (NULL == zoneindex) {
+ DEBUGMSGTL(("ipv6ScopeZoneIndexTable:container_load",
+ "couldn't get scopezone iterator\n"));
+ return MFD_RESOURCE_UNAVAILABLE;
+ }
+ /*
+ * TODO:351:M: |-> Load/update data in the ipv6ScopeZoneIndexTable container.
+ * loop over your ipv6ScopeZoneIndexTable data, allocate a rowreq context,
+ * set the index(es) [and data, optionally] and insert into
+ * the container.
+ */
+
+ CONTAINER_FOR_EACH(zoneindex,
+ (netsnmp_container_obj_func *) _snarf_zoneindex_entry,
+ container);
+ /*
+ * free the container. we've either claimed each entry, or released it,
+ * so the access function doesn't need to clear the container.
+ */
+ netsnmp_access_scopezone_container_free(zoneindex,
+ 0x0001);
+
+ DEBUGMSGT(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_container_load", "inserted %d records\n", CONTAINER_SIZE(container)));
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_container_load */
+
+/**
+ * container clean up
+ *
+ * @param container container with all current items
+ *
+ * This optional callback is called prior to all
+ * item's being removed from the container. If you
+ * need to do any processing before that, do it here.
+ *
+ * @note
+ * The MFD helper will take care of releasing all the row contexts.
+ *
+ */
+void
+ipv6ScopeZoneIndexTable_container_free(netsnmp_container * container)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_container_free", "called\n"));
+
+ /*
+ * TODO:380:M: Free ipv6ScopeZoneIndexTable container data.
+ */
+} /* ipv6ScopeZoneIndexTable_container_free */
+
+/**
+ * prepare row for processing.
+ *
+ * When the agent has located the row for a request, this function is
+ * called to prepare the row for processing. If you fully populated
+ * the data context during the index setup phase, you may not need to
+ * do anything.
+ *
+ * @param rowreq_ctx pointer to a context.
+ *
+ * @retval MFD_SUCCESS : success.
+ * @retval MFD_ERROR : other error.
+ */
+int
+ipv6ScopeZoneIndexTable_row_prep(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx)
+{
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_row_prep", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ /*
+ * TODO:390:o: Prepare row for request.
+ * If populating row data was delayed, this is the place to
+ * fill in the row for this request.
+ */
+
+ return MFD_SUCCESS;
+} /* ipv6ScopeZoneIndexTable_row_prep */
+/** @} */
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.h b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.h
new file mode 100644
index 0000000..8f98e91
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_data_access.h
@@ -0,0 +1,70 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * version : 14170 $ of $
+ *
+ * $Id:ipv6ScopeZoneIndexTable_data_access.h 14170 2007-04-29 00:12:32Z varun_c$
+ */
+#ifndef IPV6SCOPEZONEINDEXTABLE_DATA_ACCESS_H
+#define IPV6SCOPEZONEINDEXTABLE_DATA_ACCESS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+ /*
+ *********************************************************************
+ * function declarations
+ */
+
+ /*
+ *********************************************************************
+ * Table declarations
+ */
+/**********************************************************************
+ **********************************************************************
+ ***
+ *** Table ipv6ScopeZoneIndexTable
+ ***
+ **********************************************************************
+ **********************************************************************/
+ /*
+ * IP-MIB::ipv6ScopeZoneIndexTable is subid 36 of ip.
+ * Its status is Current.
+ * OID: .1.3.6.1.2.1.4.36, length: 8
+ */
+
+
+ int
+ ipv6ScopeZoneIndexTable_init_data
+ (ipv6ScopeZoneIndexTable_registration *
+ ipv6ScopeZoneIndexTable_reg);
+
+
+ void
+ ipv6ScopeZoneIndexTable_container_init(netsnmp_container **
+ container_ptr_ptr,
+ netsnmp_cache *
+ cache);
+ void
+ ipv6ScopeZoneIndexTable_container_shutdown(netsnmp_container *
+ container_ptr);
+
+ int
+ ipv6ScopeZoneIndexTable_container_load(netsnmp_container *
+ container);
+ void
+ ipv6ScopeZoneIndexTable_container_free(netsnmp_container *
+ container);
+
+#define MAX_LINE_SIZE 256
+ int
+ ipv6ScopeZoneIndexTable_row_prep(ipv6ScopeZoneIndexTable_rowreq_ctx
+ * rowreq_ctx);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* IPV6SCOPEZONEINDEXTABLE_DATA_ACCESS_H */
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_enums.h b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_enums.h
new file mode 100644
index 0000000..a79ec88
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_enums.h
@@ -0,0 +1,39 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * : generic-table-enums.m2c 12526 2005-07-15 22:41:16Z rstory $
+ *
+ * $Id:ipv6ScopeZoneIndexTable_enums.h 14170 2007-04-29 00:12:32Z varun_c$
+ */
+#ifndef IPV6SCOPEZONEINDEXTABLE_ENUMS_H
+#define IPV6SCOPEZONEINDEXTABLE_ENUMS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ /*
+ * NOTES on enums
+ * ==============
+ *
+ * Value Mapping
+ * -------------
+ * If the values for your data type don't exactly match the
+ * possible values defined by the mib, you should map them
+ * below. For example, a boolean flag (1/0) is usually represented
+ * as a TruthValue in a MIB, which maps to the values (1/2).
+ *
+ */
+/*************************************************************************
+ *************************************************************************
+ *
+ * enum definitions for table ipv6ScopeZoneIndexTable
+ *
+ *************************************************************************
+ *************************************************************************/
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* IPV6SCOPEZONEINDEXTABLE_ENUMS_H */
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.c b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.c
new file mode 100644
index 0000000..40769ad
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.c
@@ -0,0 +1,1124 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * version : 15899 $ of $
+ *
+ * $Id:ipv6ScopeZoneIndexTable_interface.c 14170 2007-04-29 00:12:32Z varun_c$
+ */
+/*
+ * *********************************************************************
+ * *********************************************************************
+ * *********************************************************************
+ * *** ***
+ * *** NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE ***
+ * *** ***
+ * *** ***
+ * *** THIS FILE DOES NOT CONTAIN ANY USER EDITABLE CODE. ***
+ * *** ***
+ * *** ***
+ * *** THE GENERATED CODE IS INTERNAL IMPLEMENTATION, AND ***
+ * *** ***
+ * *** ***
+ * *** IS SUBJECT TO CHANGE WITHOUT WARNING IN FUTURE RELEASES. ***
+ * *** ***
+ * *** ***
+ * *********************************************************************
+ * *********************************************************************
+ * *********************************************************************
+ */
+
+/*
+ * standard Net-SNMP includes
+ */
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+/*
+ * include our parent header
+ */
+#include "ipv6ScopeZoneIndexTable.h"
+
+
+#include <net-snmp/agent/table_container.h>
+#include <net-snmp/library/container.h>
+
+#include "ipv6ScopeZoneIndexTable_interface.h"
+
+#include <ctype.h>
+
+/**********************************************************************
+ **********************************************************************
+ ***
+ *** Table ipv6ScopeZoneIndexTable
+ ***
+ **********************************************************************
+ **********************************************************************/
+/*
+ * IP-MIB::ipv6ScopeZoneIndexTable is subid 36 of ip.
+ * Its status is Current.
+ * OID: .1.3.6.1.2.1.4.36, length: 8
+ */
+typedef struct ipv6ScopeZoneIndexTable_interface_ctx_s {
+
+ netsnmp_container *container;
+ netsnmp_cache *cache;
+ ipv6ScopeZoneIndexTable_registration *user_ctx;
+
+ netsnmp_table_registration_info tbl_info;
+
+ netsnmp_baby_steps_access_methods access_multiplexer;
+
+} ipv6ScopeZoneIndexTable_interface_ctx;
+
+static ipv6ScopeZoneIndexTable_interface_ctx
+ ipv6ScopeZoneIndexTable_if_ctx;
+
+static void
+_ipv6ScopeZoneIndexTable_container_init
+(ipv6ScopeZoneIndexTable_interface_ctx * if_ctx);
+static void
+_ipv6ScopeZoneIndexTable_container_shutdown
+(ipv6ScopeZoneIndexTable_interface_ctx * if_ctx);
+static int
+_cache_load(netsnmp_cache * cache, void *vmagic);
+static void
+_cache_free(netsnmp_cache * cache, void *magic);
+
+
+netsnmp_container *
+ipv6ScopeZoneIndexTable_container_get(void)
+{
+ return ipv6ScopeZoneIndexTable_if_ctx.container;
+}
+
+ipv6ScopeZoneIndexTable_registration *
+ipv6ScopeZoneIndexTable_registration_get(void)
+{
+ return ipv6ScopeZoneIndexTable_if_ctx.user_ctx;
+}
+
+ipv6ScopeZoneIndexTable_registration *
+ipv6ScopeZoneIndexTable_registration_set
+ (ipv6ScopeZoneIndexTable_registration * newreg)
+{
+ ipv6ScopeZoneIndexTable_registration *old =
+ ipv6ScopeZoneIndexTable_if_ctx.user_ctx;
+ ipv6ScopeZoneIndexTable_if_ctx.user_ctx = newreg;
+ return old;
+}
+
+int
+ipv6ScopeZoneIndexTable_container_size(void)
+{
+ return CONTAINER_SIZE(ipv6ScopeZoneIndexTable_if_ctx.container);
+}
+
+/*
+ * mfd multiplexer modes
+ */
+static Netsnmp_Node_Handler _mfd_ipv6ScopeZoneIndexTable_pre_request;
+static Netsnmp_Node_Handler _mfd_ipv6ScopeZoneIndexTable_post_request;
+static Netsnmp_Node_Handler _mfd_ipv6ScopeZoneIndexTable_object_lookup;
+static Netsnmp_Node_Handler _mfd_ipv6ScopeZoneIndexTable_get_values;
+/**
+ * @internal
+ * Initialize the table ipv6ScopeZoneIndexTable
+ * (Define its contents and how it's structured)
+ */
+void
+_ipv6ScopeZoneIndexTable_initialize_interface
+ (ipv6ScopeZoneIndexTable_registration * reg_ptr, u_long flags)
+{
+ netsnmp_baby_steps_access_methods *access_multiplexer =
+ &ipv6ScopeZoneIndexTable_if_ctx.access_multiplexer;
+ netsnmp_table_registration_info *tbl_info =
+ &ipv6ScopeZoneIndexTable_if_ctx.tbl_info;
+ netsnmp_handler_registration *reginfo;
+ netsnmp_mib_handler *handler;
+ int mfd_modes = 0;
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_ipv6ScopeZoneIndexTable_initialize_interface", "called\n"));
+
+
+ /*************************************************
+ *
+ * save interface context for ipv6ScopeZoneIndexTable
+ */
+ /*
+ * Setting up the table's definition
+ */
+ netsnmp_table_helper_add_indexes(tbl_info, ASN_INTEGER,
+ /** index: ipv6ScopeZoneIndexIfIndex */
+ 0);
+
+ /*
+ * Define the minimum and maximum accessible columns. This
+ * optimizes retrival.
+ */
+ tbl_info->min_column = IPV6SCOPEZONEINDEXTABLE_MIN_COL;
+ tbl_info->max_column = IPV6SCOPEZONEINDEXTABLE_MAX_COL;
+
+ /*
+ * save users context
+ */
+ ipv6ScopeZoneIndexTable_if_ctx.user_ctx = reg_ptr;
+
+ /*
+ * call data access initialization code
+ */
+ ipv6ScopeZoneIndexTable_init_data(reg_ptr);
+
+ /*
+ * set up the container
+ */
+ _ipv6ScopeZoneIndexTable_container_init
+ (&ipv6ScopeZoneIndexTable_if_ctx);
+ if (NULL == ipv6ScopeZoneIndexTable_if_ctx.container) {
+ snmp_log(LOG_ERR,
+ "could not initialize container for ipv6ScopeZoneIndexTable\n");
+ return;
+ }
+
+ /*
+ * access_multiplexer: REQUIRED wrapper for get request handling
+ */
+ access_multiplexer->object_lookup =
+ _mfd_ipv6ScopeZoneIndexTable_object_lookup;
+ access_multiplexer->get_values =
+ _mfd_ipv6ScopeZoneIndexTable_get_values;
+
+ /*
+ * no wrappers yet
+ */
+ access_multiplexer->pre_request =
+ _mfd_ipv6ScopeZoneIndexTable_pre_request;
+ access_multiplexer->post_request =
+ _mfd_ipv6ScopeZoneIndexTable_post_request;
+
+
+ /*************************************************
+ *
+ * Create a registration, save our reg data, register table.
+ */
+ DEBUGMSGTL(("ipv6ScopeZoneIndexTable:init_ipv6ScopeZoneIndexTable",
+ "Registering ipv6ScopeZoneIndexTable as a mibs-for-dummies table.\n"));
+ handler =
+ netsnmp_baby_steps_access_multiplexer_get(access_multiplexer);
+ reginfo =
+ netsnmp_handler_registration_create("ipv6ScopeZoneIndexTable",
+ handler,
+ ipv6ScopeZoneIndexTable_oid,
+ ipv6ScopeZoneIndexTable_oid_size,
+ HANDLER_CAN_BABY_STEP |
+ HANDLER_CAN_RONLY);
+ if (NULL == reginfo) {
+ snmp_log(LOG_ERR,
+ "error registering table ipv6ScopeZoneIndexTable\n");
+ return;
+ }
+ reginfo->my_reg_void = &ipv6ScopeZoneIndexTable_if_ctx;
+
+ /*************************************************
+ *
+ * set up baby steps handler, create it and inject it
+ */
+ if (access_multiplexer->object_lookup)
+ mfd_modes |= BABY_STEP_OBJECT_LOOKUP;
+ if (access_multiplexer->set_values)
+ mfd_modes |= BABY_STEP_SET_VALUES;
+ if (access_multiplexer->irreversible_commit)
+ mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT;
+ if (access_multiplexer->object_syntax_checks)
+ mfd_modes |= BABY_STEP_CHECK_OBJECT;
+
+ if (access_multiplexer->pre_request)
+ mfd_modes |= BABY_STEP_PRE_REQUEST;
+ if (access_multiplexer->post_request)
+ mfd_modes |= BABY_STEP_POST_REQUEST;
+
+ if (access_multiplexer->undo_setup)
+ mfd_modes |= BABY_STEP_UNDO_SETUP;
+ if (access_multiplexer->undo_cleanup)
+ mfd_modes |= BABY_STEP_UNDO_CLEANUP;
+ if (access_multiplexer->undo_sets)
+ mfd_modes |= BABY_STEP_UNDO_SETS;
+
+ if (access_multiplexer->row_creation)
+ mfd_modes |= BABY_STEP_ROW_CREATE;
+ if (access_multiplexer->consistency_checks)
+ mfd_modes |= BABY_STEP_CHECK_CONSISTENCY;
+ if (access_multiplexer->commit)
+ mfd_modes |= BABY_STEP_COMMIT;
+ if (access_multiplexer->undo_commit)
+ mfd_modes |= BABY_STEP_UNDO_COMMIT;
+
+ handler = netsnmp_baby_steps_handler_get(mfd_modes);
+ netsnmp_inject_handler(reginfo, handler);
+
+ /*************************************************
+ *
+ * inject row_merge helper with prefix rootoid_len + 2 (entry.col)
+ */
+ handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2);
+ netsnmp_inject_handler(reginfo, handler);
+
+ /*************************************************
+ *
+ * inject container_table helper
+ */
+ handler =
+ netsnmp_container_table_handler_get(tbl_info,
+ ipv6ScopeZoneIndexTable_if_ctx.
+ container,
+ TABLE_CONTAINER_KEY_NETSNMP_INDEX);
+ netsnmp_inject_handler(reginfo, handler);
+
+ if (NULL != ipv6ScopeZoneIndexTable_if_ctx.cache) {
+ handler =
+ netsnmp_cache_handler_get(ipv6ScopeZoneIndexTable_if_ctx.cache);
+ netsnmp_inject_handler(reginfo, handler);
+ }
+
+ /*
+ * register table
+ */
+ netsnmp_register_table(reginfo, tbl_info);
+
+} /* _ipv6ScopeZoneIndexTable_initialize_interface */
+
+/**
+ * @internal
+ * Shutdown the table ipv6ScopeZoneIndexTable
+ */
+void
+_ipv6ScopeZoneIndexTable_shutdown_interface
+ (ipv6ScopeZoneIndexTable_registration * reg_ptr)
+{
+ /*
+ * shutdown the container
+ */
+ _ipv6ScopeZoneIndexTable_container_shutdown
+ (&ipv6ScopeZoneIndexTable_if_ctx);
+}
+
+void
+ipv6ScopeZoneIndexTable_valid_columns_set(netsnmp_column_info *vc)
+{
+ ipv6ScopeZoneIndexTable_if_ctx.tbl_info.valid_columns = vc;
+} /* ipv6ScopeZoneIndexTable_valid_columns_set */
+
+/**
+ * @internal
+ * convert the index component stored in the context to an oid
+ */
+int
+ipv6ScopeZoneIndexTable_index_to_oid(netsnmp_index * oid_idx,
+ ipv6ScopeZoneIndexTable_mib_index *
+ mib_idx)
+{
+ int err = SNMP_ERR_NOERROR;
+
+ /*
+ * temp storage for parsing indexes
+ */
+ /*
+ * ipv6ScopeZoneIndexIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
+ */
+ netsnmp_variable_list var_ipv6ScopeZoneIndexIfIndex;
+
+ /*
+ * set up varbinds
+ */
+ memset(&var_ipv6ScopeZoneIndexIfIndex, 0x00,
+ sizeof(var_ipv6ScopeZoneIndexIfIndex));
+ var_ipv6ScopeZoneIndexIfIndex.type = ASN_INTEGER;
+
+ /*
+ * chain temp index varbinds together
+ */
+ var_ipv6ScopeZoneIndexIfIndex.next_variable = NULL;
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_index_to_oid", "called\n"));
+
+ /*
+ * ipv6ScopeZoneIndexIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
+ */
+ snmp_set_var_value(&var_ipv6ScopeZoneIndexIfIndex,
+ (u_char *) & mib_idx->ipv6ScopeZoneIndexIfIndex,
+ sizeof(mib_idx->ipv6ScopeZoneIndexIfIndex));
+
+
+ err = build_oid_noalloc(oid_idx->oids, oid_idx->len, &oid_idx->len,
+ NULL, 0, &var_ipv6ScopeZoneIndexIfIndex);
+ if (err)
+ snmp_log(LOG_ERR, "error %d converting index to oid\n", err);
+
+ /*
+ * parsing may have allocated memory. free it.
+ */
+ snmp_reset_var_buffers(&var_ipv6ScopeZoneIndexIfIndex);
+
+ return err;
+} /* ipv6ScopeZoneIndexTable_index_to_oid */
+
+/**
+ * extract ipv6ScopeZoneIndexTable indexes from a netsnmp_index
+ *
+ * @retval SNMP_ERR_NOERROR : no error
+ * @retval SNMP_ERR_GENERR : error
+ */
+int
+ipv6ScopeZoneIndexTable_index_from_oid(netsnmp_index * oid_idx,
+ ipv6ScopeZoneIndexTable_mib_index *
+ mib_idx)
+{
+ int err = SNMP_ERR_NOERROR;
+
+ /*
+ * temp storage for parsing indexes
+ */
+ /*
+ * ipv6ScopeZoneIndexIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
+ */
+ netsnmp_variable_list var_ipv6ScopeZoneIndexIfIndex;
+
+ /*
+ * set up varbinds
+ */
+ memset(&var_ipv6ScopeZoneIndexIfIndex, 0x00,
+ sizeof(var_ipv6ScopeZoneIndexIfIndex));
+ var_ipv6ScopeZoneIndexIfIndex.type = ASN_INTEGER;
+
+ /*
+ * chain temp index varbinds together
+ */
+ var_ipv6ScopeZoneIndexIfIndex.next_variable = NULL;
+
+
+ DEBUGMSGTL(("verbose:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_index_from_oid", "called\n"));
+
+ /*
+ * parse the oid into the individual index components
+ */
+ err = parse_oid_indexes(oid_idx->oids, oid_idx->len,
+ &var_ipv6ScopeZoneIndexIfIndex);
+ if (err == SNMP_ERR_NOERROR) {
+ /*
+ * copy out values
+ */
+ mib_idx->ipv6ScopeZoneIndexIfIndex =
+ *((long *) var_ipv6ScopeZoneIndexIfIndex.val.string);
+
+
+ }
+
+ /*
+ * parsing may have allocated memory. free it.
+ */
+ snmp_reset_var_buffers(&var_ipv6ScopeZoneIndexIfIndex);
+
+ return err;
+} /* ipv6ScopeZoneIndexTable_index_from_oid */
+
+
+/*
+ *********************************************************************
+ * @internal
+ * allocate resources for a ipv6ScopeZoneIndexTable_rowreq_ctx
+ */
+ipv6ScopeZoneIndexTable_rowreq_ctx *
+ipv6ScopeZoneIndexTable_allocate_rowreq_ctx(ipv6ScopeZoneIndexTable_data *data,
+ void *user_init_ctx)
+{
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx =
+ SNMP_MALLOC_TYPEDEF(ipv6ScopeZoneIndexTable_rowreq_ctx);
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_allocate_rowreq_ctx", "called\n"));
+
+ if (NULL == rowreq_ctx) {
+ snmp_log(LOG_ERR, "Couldn't allocate memory for a "
+ "ipv6ScopeZoneIndexTable_rowreq_ctx.\n");
+ return NULL;
+ } else {
+ if (NULL != data) {
+ /*
+ * track if we got data from user
+ */
+ rowreq_ctx->rowreq_flags |= MFD_ROW_DATA_FROM_USER;
+ rowreq_ctx->data = data;
+ } else if (NULL ==
+ (rowreq_ctx->data =
+ ipv6ScopeZoneIndexTable_allocate_data())) {
+ SNMP_FREE(rowreq_ctx);
+ return NULL;
+ }
+ }
+
+
+ rowreq_ctx->oid_idx.oids = rowreq_ctx->oid_tmp;
+
+ rowreq_ctx->ipv6ScopeZoneIndexTable_data_list = NULL;
+
+ /*
+ * if we allocated data, call init routine
+ */
+ if (!(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER)) {
+ if (SNMPERR_SUCCESS !=
+ ipv6ScopeZoneIndexTable_rowreq_ctx_init(rowreq_ctx,
+ user_init_ctx)) {
+ ipv6ScopeZoneIndexTable_release_rowreq_ctx(rowreq_ctx);
+ rowreq_ctx = NULL;
+ }
+ }
+
+ return rowreq_ctx;
+} /* ipv6ScopeZoneIndexTable_allocate_rowreq_ctx */
+
+/*
+ * @internal
+ * release resources for a ipv6ScopeZoneIndexTable_rowreq_ctx
+ */
+void
+ipv6ScopeZoneIndexTable_release_rowreq_ctx
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx)
+{
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:ipv6ScopeZoneIndexTable_release_rowreq_ctx", "called\n"));
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ ipv6ScopeZoneIndexTable_rowreq_ctx_cleanup(rowreq_ctx);
+ /*
+ * for non-transient data, don't free data we got from the user
+ */
+ if ((rowreq_ctx->data) &&
+ !(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER))
+ ipv6ScopeZoneIndexTable_release_data(rowreq_ctx->data);
+
+
+ /*
+ * free index oid pointer
+ */
+ if (rowreq_ctx->oid_idx.oids != rowreq_ctx->oid_tmp)
+ free(rowreq_ctx->oid_idx.oids);
+
+ SNMP_FREE(rowreq_ctx);
+} /* ipv6ScopeZoneIndexTable_release_rowreq_ctx */
+
+/**
+ * @internal
+ * wrapper
+ */
+static int
+_mfd_ipv6ScopeZoneIndexTable_pre_request(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration
+ *reginfo,
+ netsnmp_agent_request_info
+ *agtreq_info,
+ netsnmp_request_info *requests)
+{
+ int rc;
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_pre_request", "called\n"));
+
+ if (1 != netsnmp_row_merge_status_first(reginfo, agtreq_info)) {
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable",
+ "skipping additional pre_request\n"));
+ return SNMP_ERR_NOERROR;
+ }
+
+ rc = ipv6ScopeZoneIndexTable_pre_request
+ (ipv6ScopeZoneIndexTable_if_ctx.user_ctx);
+ if (MFD_SUCCESS != rc) {
+ /*
+ * nothing we can do about it but log it
+ */
+ DEBUGMSGTL(("ipv6ScopeZoneIndexTable", "error %d from "
+ "ipv6ScopeZoneIndexTable_pre_request\n", rc));
+ netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
+ }
+
+ return SNMP_ERR_NOERROR;
+} /* _mfd_ipv6ScopeZoneIndexTable_pre_request */
+
+/**
+ * @internal
+ * wrapper
+ */
+static int
+_mfd_ipv6ScopeZoneIndexTable_post_request(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration
+ *reginfo,
+ netsnmp_agent_request_info
+ *agtreq_info,
+ netsnmp_request_info *requests)
+{
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx =
+ netsnmp_container_table_row_extract(requests);
+ int rc, packet_rc;
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_post_request", "called\n"));
+
+ /*
+ * release row context, if deleted
+ */
+ if (rowreq_ctx && (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED))
+ ipv6ScopeZoneIndexTable_release_rowreq_ctx(rowreq_ctx);
+
+ /*
+ * wait for last call before calling user
+ */
+ if (1 != netsnmp_row_merge_status_last(reginfo, agtreq_info)) {
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable",
+ "waiting for last post_request\n"));
+ return SNMP_ERR_NOERROR;
+ }
+
+ packet_rc = netsnmp_check_all_requests_error(agtreq_info->asp, 0);
+ rc = ipv6ScopeZoneIndexTable_post_request
+ (ipv6ScopeZoneIndexTable_if_ctx.user_ctx, packet_rc);
+ if (MFD_SUCCESS != rc) {
+ /*
+ * nothing we can do about it but log it
+ */
+ DEBUGMSGTL(("ipv6ScopeZoneIndexTable", "error %d from "
+ "ipv6ScopeZoneIndexTable_post_request\n", rc));
+ }
+
+ return SNMP_ERR_NOERROR;
+} /* _mfd_ipv6ScopeZoneIndexTable_post_request */
+
+/**
+ * @internal
+ * wrapper
+ */
+static ipv6ScopeZoneIndexTable_rowreq_ctx *
+_mfd_ipv6ScopeZoneIndexTable_rowreq_from_index(netsnmp_index * oid_idx,
+ int *rc_ptr)
+{
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx;
+ ipv6ScopeZoneIndexTable_mib_index mib_idx;
+ int rc;
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_rowreq_from_index", "called\n"));
+
+ if (NULL == rc_ptr)
+ rc_ptr = &rc;
+ *rc_ptr = MFD_SUCCESS;
+
+ memset(&mib_idx, 0x0, sizeof(mib_idx));
+
+ /*
+ * try to parse oid
+ */
+ *rc_ptr = ipv6ScopeZoneIndexTable_index_from_oid(oid_idx, &mib_idx);
+ if (MFD_SUCCESS != *rc_ptr) {
+ DEBUGMSGT(("ipv6ScopeZoneIndexTable", "error parsing index\n"));
+ return NULL;
+ }
+
+ /*
+ * allocate new context
+ */
+ rowreq_ctx = ipv6ScopeZoneIndexTable_allocate_rowreq_ctx(NULL, NULL);
+ if (NULL == rowreq_ctx) {
+ *rc_ptr = MFD_ERROR;
+ return NULL; /* msg already logged */
+ }
+
+ memcpy(&rowreq_ctx->tbl_idx, &mib_idx, sizeof(mib_idx));
+
+
+ /*
+ * copy indexes
+ */
+ rowreq_ctx->oid_idx.len = oid_idx->len;
+ memcpy(rowreq_ctx->oid_idx.oids, oid_idx->oids,
+ oid_idx->len * sizeof(oid));
+
+ return rowreq_ctx;
+} /* _mfd_ipv6ScopeZoneIndexTable_rowreq_from_index */
+
+/**
+ * @internal
+ * wrapper
+ */
+static int
+_mfd_ipv6ScopeZoneIndexTable_object_lookup(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration
+ *reginfo,
+ netsnmp_agent_request_info
+ *agtreq_info,
+ netsnmp_request_info *requests)
+{
+ int rc = SNMP_ERR_NOERROR;
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx =
+ netsnmp_container_table_row_extract(requests);
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_object_lookup", "called\n"));
+
+ /*
+ * get our context from mfd
+ * ipv6ScopeZoneIndexTable_interface_ctx *if_ctx =
+ * (ipv6ScopeZoneIndexTable_interface_ctx *)reginfo->my_reg_void;
+ */
+
+ if (NULL == rowreq_ctx) {
+ netsnmp_table_request_info *tblreq_info;
+ netsnmp_index oid_idx;
+
+ tblreq_info = netsnmp_extract_table_info(requests);
+ if (NULL == tblreq_info) {
+ snmp_log(LOG_ERR, "request had no table info\n");
+ return MFD_ERROR;
+ }
+
+ /*
+ * try create rowreq
+ */
+ oid_idx.oids = tblreq_info->index_oid;
+ oid_idx.len = tblreq_info->index_oid_len;
+
+ rowreq_ctx =
+ _mfd_ipv6ScopeZoneIndexTable_rowreq_from_index(&oid_idx, &rc);
+ if (MFD_SUCCESS == rc) {
+ netsnmp_assert(NULL != rowreq_ctx);
+ rowreq_ctx->rowreq_flags |= MFD_ROW_CREATED;
+ /*
+ * add rowreq_ctx to request data lists
+ */
+ netsnmp_container_table_row_insert(requests, (netsnmp_index *)
+ rowreq_ctx);
+ }
+
+ }
+
+ if (MFD_SUCCESS != rc)
+ netsnmp_request_set_error_all(requests, rc);
+ else
+ ipv6ScopeZoneIndexTable_row_prep(rowreq_ctx);
+
+ return SNMP_VALIDATE_ERR(rc);
+} /* _mfd_ipv6ScopeZoneIndexTable_object_lookup */
+
+/***********************************************************************
+ *
+ * GET processing
+ *
+ ***********************************************************************/
+/*
+ * @internal
+ * Retrieve the value for a particular column
+ */
+NETSNMP_STATIC_INLINE int
+_ipv6ScopeZoneIndexTable_get_column(ipv6ScopeZoneIndexTable_rowreq_ctx *
+ rowreq_ctx,
+ netsnmp_variable_list * var,
+ int column)
+{
+ int rc = SNMPERR_SUCCESS;
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_get_column", "called for %d\n", column));
+
+
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ switch (column) {
+
+ /*
+ * ipv6ScopeZoneIndexLinkLocal(2)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXLINKLOCAL:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexLinkLocal_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndex3(3)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEX3:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndex3_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexAdminLocal(4)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXADMINLOCAL:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexAdminLocal_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexSiteLocal(5)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXSITELOCAL:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexSiteLocal_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndex6(6)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEX6:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndex6_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndex7(7)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEX7:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndex7_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexOrganizationLocal(8)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXORGANIZATIONLOCAL:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexOrganizationLocal_get(rowreq_ctx,
+ (u_long *) var->val.
+ string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndex9(9)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEX9:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndex9_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexA(10)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXA:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexA_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexB(11)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXB:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexB_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexC(12)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXC:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexC_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ /*
+ * ipv6ScopeZoneIndexD(13)/InetZoneIndex/ASN_UNSIGNED/u_long(u_long)//l/A/w/e/r/d/H
+ */
+ case COLUMN_IPV6SCOPEZONEINDEXD:
+ var->val_len = sizeof(u_long);
+ var->type = ASN_UNSIGNED;
+ rc = ipv6ScopeZoneIndexD_get(rowreq_ctx,
+ (u_long *) var->val.string);
+ break;
+
+ default:
+ if (IPV6SCOPEZONEINDEXTABLE_MIN_COL <= column
+ && column <= IPV6SCOPEZONEINDEXTABLE_MAX_COL) {
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_get_column", "assume column %d is reserved\n", column));
+ rc = MFD_SKIP;
+ } else {
+ snmp_log(LOG_ERR,
+ "unknown column %d in _ipv6ScopeZoneIndexTable_get_column\n",
+ column);
+ }
+ break;
+ }
+
+ return rc;
+} /* _ipv6ScopeZoneIndexTable_get_column */
+
+int
+_mfd_ipv6ScopeZoneIndexTable_get_values(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration
+ *reginfo,
+ netsnmp_agent_request_info
+ *agtreq_info,
+ netsnmp_request_info *requests)
+{
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx =
+ netsnmp_container_table_row_extract(requests);
+ netsnmp_table_request_info *tri;
+ u_char *old_string;
+ void (*dataFreeHook) (void *);
+ int rc;
+
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_mfd_ipv6ScopeZoneIndexTable_get_values", "called\n"));
+ netsnmp_assert(NULL != rowreq_ctx);
+
+ for (; requests; requests = requests->next) {
+ /*
+ * save old pointer, so we can free it if replaced
+ */
+ old_string = requests->requestvb->val.string;
+ dataFreeHook = requests->requestvb->dataFreeHook;
+ if (NULL == requests->requestvb->val.string) {
+ requests->requestvb->val.string = requests->requestvb->buf;
+ requests->requestvb->val_len =
+ sizeof(requests->requestvb->buf);
+ } else if (requests->requestvb->buf ==
+ requests->requestvb->val.string) {
+ if (requests->requestvb->val_len !=
+ sizeof(requests->requestvb->buf))
+ requests->requestvb->val_len =
+ sizeof(requests->requestvb->buf);
+ }
+
+ /*
+ * get column data
+ */
+ tri = netsnmp_extract_table_info(requests);
+ if (NULL == tri)
+ continue;
+
+ rc = _ipv6ScopeZoneIndexTable_get_column(rowreq_ctx,
+ requests->requestvb,
+ tri->colnum);
+ if (rc) {
+ if (MFD_SKIP == rc) {
+ requests->requestvb->type = SNMP_NOSUCHINSTANCE;
+ rc = SNMP_ERR_NOERROR;
+ }
+ } else if (NULL == requests->requestvb->val.string) {
+ snmp_log(LOG_ERR, "NULL varbind data pointer!\n");
+ rc = SNMP_ERR_GENERR;
+ }
+ if (rc)
+ netsnmp_request_set_error(requests, SNMP_VALIDATE_ERR(rc));
+
+ /*
+ * if the buffer wasn't used previously for the old data (i.e. it
+ * was allcoated memory) and the get routine replaced the pointer,
+ * we need to free the previous pointer.
+ */
+ if (old_string && (old_string != requests->requestvb->buf) &&
+ (requests->requestvb->val.string != old_string)) {
+ if (dataFreeHook)
+ (*dataFreeHook) (old_string);
+ else
+ free(old_string);
+ }
+ } /* for results */
+
+ return SNMP_ERR_NOERROR;
+} /* _mfd_ipv6ScopeZoneIndexTable_get_values */
+
+
+/***********************************************************************
+ *
+ * SET processing
+ *
+ ***********************************************************************/
+
+/*
+ * SET PROCESSING NOT APPLICABLE (per MIB or user setting)
+ */
+/***********************************************************************
+ *
+ * DATA ACCESS
+ *
+ ***********************************************************************/
+/**
+ * @internal
+ */
+static void
+_container_item_free(ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx,
+ void *context)
+{
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_container_item_free",
+ "called\n"));
+
+ if (NULL == rowreq_ctx)
+ return;
+
+ ipv6ScopeZoneIndexTable_release_rowreq_ctx(rowreq_ctx);
+} /* _container_item_free */
+
+/**
+ * @internal
+ */
+static void
+_container_free(netsnmp_container * container)
+{
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_container_free",
+ "called\n"));
+
+ if (NULL == container) {
+ snmp_log(LOG_ERR,
+ "invalid container in ipv6ScopeZoneIndexTable_container_free\n");
+ return;
+ }
+
+ /*
+ * call user code
+ */
+ ipv6ScopeZoneIndexTable_container_free(container);
+
+ /*
+ * free all items. inefficient, but easy.
+ */
+ CONTAINER_CLEAR(container,
+ (netsnmp_container_obj_func *) _container_item_free,
+ NULL);
+} /* _container_free */
+
+/**
+ * @internal
+ * initialize the container with functions or wrappers
+ */
+void
+_ipv6ScopeZoneIndexTable_container_init
+ (ipv6ScopeZoneIndexTable_interface_ctx * if_ctx)
+{
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_ipv6ScopeZoneIndexTable_container_init", "called\n"));
+
+ /*
+ * container init
+ */
+ if_ctx->cache = netsnmp_cache_create(30, /* timeout in seconds */
+ _cache_load, _cache_free,
+ ipv6ScopeZoneIndexTable_oid,
+ ipv6ScopeZoneIndexTable_oid_size);
+
+ if (NULL == if_ctx->cache) {
+ snmp_log(LOG_ERR, "error creating cache for ipScopeZoneIndexTable\n");
+ return;
+ }
+
+ if_ctx->cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET;
+
+ ipv6ScopeZoneIndexTable_container_init(&if_ctx->container, if_ctx->cache);
+ if (NULL == if_ctx->container)
+ if_ctx->container =
+ netsnmp_container_find
+ ("ipv6ScopeZoneIndexTable:table_container");
+ if (NULL == if_ctx->container) {
+ snmp_log(LOG_ERR, "error creating container in "
+ "ipv6ScopeZoneIndexTable_container_init\n");
+ return;
+ }
+ if (NULL != if_ctx->cache)
+ if_ctx->cache->magic = (void *) if_ctx->container;
+
+
+} /* _ipv6ScopeZoneIndexTable_container_init */
+
+/**
+ * @internal
+ * shutdown the container with functions or wrappers
+ */
+void
+_ipv6ScopeZoneIndexTable_container_shutdown
+ (ipv6ScopeZoneIndexTable_interface_ctx * if_ctx)
+{
+ DEBUGMSGTL(("internal:ipv6ScopeZoneIndexTable:_ipv6ScopeZoneIndexTable_container_shutdown", "called\n"));
+
+ ipv6ScopeZoneIndexTable_container_shutdown(if_ctx->container);
+
+ _container_free(if_ctx->container);
+
+} /* _ipv6ScopeZoneIndexTable_container_shutdown */
+
+
+ipv6ScopeZoneIndexTable_rowreq_ctx *
+ipv6ScopeZoneIndexTable_row_find_by_mib_index
+ (ipv6ScopeZoneIndexTable_mib_index * mib_idx)
+{
+ ipv6ScopeZoneIndexTable_rowreq_ctx *rowreq_ctx;
+ oid oid_tmp[MAX_OID_LEN];
+ netsnmp_index oid_idx;
+ int rc;
+
+ /*
+ * set up storage for OID
+ */
+ oid_idx.oids = oid_tmp;
+ oid_idx.len = sizeof(oid_tmp) / sizeof(oid);
+
+ /*
+ * convert
+ */
+ rc = ipv6ScopeZoneIndexTable_index_to_oid(&oid_idx, mib_idx);
+ if (MFD_SUCCESS != rc)
+ return NULL;
+
+ rowreq_ctx =
+ CONTAINER_FIND(ipv6ScopeZoneIndexTable_if_ctx.container, &oid_idx);
+
+ return rowreq_ctx;
+}
+
+static int
+_cache_load(netsnmp_cache * cache, void *vmagic)
+{
+ DEBUGMSGTL(("internal:ipScopeZoneIndexTable:_cache_load", "called\n"));
+
+ if ((NULL == cache) || (NULL == cache->magic)) {
+ snmp_log(LOG_ERR,
+ "invalid cache for ipScopeZoneIndexTable_cache_load\n");
+ return -1;
+ }
+ /** should only be called for an invalid or expired cache */
+ netsnmp_assert((0 == cache->valid) || (1 == cache->expired));
+
+ /*
+ * call user code
+ */
+ return ipv6ScopeZoneIndexTable_container_load((netsnmp_container *) cache->
+ magic);
+} /* _cache_load */
+
+/**
+ * @internal
+ */
+static void
+_cache_free(netsnmp_cache * cache, void *magic)
+{
+ netsnmp_container *container;
+
+ DEBUGMSGTL(("internal:ipScopeZoneIndexTable:_cache_free", "called\n"));
+
+ if ((NULL == cache) || (NULL == cache->magic)) {
+ snmp_log(LOG_ERR,
+ "invalid cache in ipScopeZoneIndexTable_cache_free\n");
+ return;
+ }
+
+ container = (netsnmp_container *) cache->magic;
+
+ _container_free(container);
+} /* _cache_free */
+
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.h b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.h
new file mode 100644
index 0000000..7fc3109
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_interface.h
@@ -0,0 +1,98 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * version : 15899 $ of $
+ *
+ * $Id:ipv6ScopeZoneIndexTable_interface.h 14170 2007-04-29 00:12:32Z varun_c$
+ */
+/** @ingroup interface: Routines to interface to Net-SNMP
+ *
+ * \warning This code should not be modified, called directly,
+ * or used to interpret functionality. It is subject to
+ * change at any time.
+ *
+ * @{
+ */
+/*
+ * *********************************************************************
+ * *********************************************************************
+ * *********************************************************************
+ * *** ***
+ * *** NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE ***
+ * *** ***
+ * *** ***
+ * *** THIS FILE DOES NOT CONTAIN ANY USER EDITABLE CODE. ***
+ * *** ***
+ * *** ***
+ * *** THE GENERATED CODE IS INTERNAL IMPLEMENTATION, AND ***
+ * *** ***
+ * *** ***
+ * *** IS SUBJECT TO CHANGE WITHOUT WARNING IN FUTURE RELEASES. ***
+ * *** ***
+ * *** ***
+ * *********************************************************************
+ * *********************************************************************
+ * *********************************************************************
+ */
+#ifndef IPV6SCOPEZONEINDEXTABLE_INTERFACE_H
+#define IPV6SCOPEZONEINDEXTABLE_INTERFACE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "ipv6ScopeZoneIndexTable.h"
+
+
+ /*
+ ********************************************************************
+ * Table declarations
+ */
+
+ /*
+ * PUBLIC interface initialization routine
+ */
+ void
+ _ipv6ScopeZoneIndexTable_initialize_interface
+ (ipv6ScopeZoneIndexTable_registration * user_ctx, u_long flags);
+ void
+ _ipv6ScopeZoneIndexTable_shutdown_interface
+ (ipv6ScopeZoneIndexTable_registration * user_ctx);
+
+ ipv6ScopeZoneIndexTable_registration
+ *ipv6ScopeZoneIndexTable_registration_get(void);
+
+ ipv6ScopeZoneIndexTable_registration
+ *ipv6ScopeZoneIndexTable_registration_set
+ (ipv6ScopeZoneIndexTable_registration * newreg);
+
+ netsnmp_container *ipv6ScopeZoneIndexTable_container_get(void);
+ int ipv6ScopeZoneIndexTable_container_size(void);
+
+ ipv6ScopeZoneIndexTable_rowreq_ctx
+ *ipv6ScopeZoneIndexTable_allocate_rowreq_ctx(ipv6ScopeZoneIndexTable_data *, void *);
+ void
+ ipv6ScopeZoneIndexTable_release_rowreq_ctx
+ (ipv6ScopeZoneIndexTable_rowreq_ctx * rowreq_ctx);
+
+ int ipv6ScopeZoneIndexTable_index_to_oid(netsnmp_index *
+ oid_idx,
+ ipv6ScopeZoneIndexTable_mib_index
+ * mib_idx);
+ int ipv6ScopeZoneIndexTable_index_from_oid(netsnmp_index *
+ oid_idx,
+ ipv6ScopeZoneIndexTable_mib_index
+ * mib_idx);
+
+ /*
+ * access to certain internals. use with caution!
+ */
+ void
+ ipv6ScopeZoneIndexTable_valid_columns_set(netsnmp_column_info *vc);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* IPV6SCOPEZONEINDEXTABLE_INTERFACE_H */
+/** @} */
diff --git a/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_oids.h b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_oids.h
new file mode 100644
index 0000000..134daa2
--- /dev/null
+++ b/agent/mibgroup/ip-mib/ipv6ScopeZoneIndexTable/ipv6ScopeZoneIndexTable_oids.h
@@ -0,0 +1,55 @@
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * : generic-table-oids.m2c 12855 2005-09-27 15:56:08Z rstory $
+ *
+ * $Id:ipv6ScopeZoneIndexTable_oids.h 14170 2007-04-29 00:12:32Z varun_c$
+ */
+#ifndef IPV6SCOPEZONEINDEXTABLE_OIDS_H
+#define IPV6SCOPEZONEINDEXTABLE_OIDS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+ /*
+ * column number definitions for table ipv6ScopeZoneIndexTable
+ */
+#define IPV6SCOPEZONEINDEXTABLE_OID 1,3,6,1,2,1,4,36
+
+#define COLUMN_IPV6SCOPEZONEINDEXIFINDEX 1
+
+#define COLUMN_IPV6SCOPEZONEINDEXLINKLOCAL 2
+
+#define COLUMN_IPV6SCOPEZONEINDEX3 3
+
+#define COLUMN_IPV6SCOPEZONEINDEXADMINLOCAL 4
+
+#define COLUMN_IPV6SCOPEZONEINDEXSITELOCAL 5
+
+#define COLUMN_IPV6SCOPEZONEINDEX6 6
+
+#define COLUMN_IPV6SCOPEZONEINDEX7 7
+
+#define COLUMN_IPV6SCOPEZONEINDEXORGANIZATIONLOCAL 8
+
+#define COLUMN_IPV6SCOPEZONEINDEX9 9
+
+#define COLUMN_IPV6SCOPEZONEINDEXA 10
+
+#define COLUMN_IPV6SCOPEZONEINDEXB 11
+
+#define COLUMN_IPV6SCOPEZONEINDEXC 12
+
+#define COLUMN_IPV6SCOPEZONEINDEXD 13
+
+
+#define IPV6SCOPEZONEINDEXTABLE_MIN_COL COLUMN_IPV6SCOPEZONEINDEXLINKLOCAL
+#define IPV6SCOPEZONEINDEXTABLE_MAX_COL COLUMN_IPV6SCOPEZONEINDEXD
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* IPV6SCOPEZONEINDEXTABLE_OIDS_H */
diff --git a/include/net-snmp/data_access/scopezone.h b/include/net-snmp/data_access/scopezone.h
new file mode 100644
index 0000000..de5c8bf
--- /dev/null
+++ b/include/net-snmp/data_access/scopezone.h
@@ -0,0 +1,68 @@
+/*
+ * scopezone data access header
+ *
+ * $Id: scopezone.h 14170 2007-04-29 02:22:12Z varun_c $
+ */
+#ifndef NETSNMP_ACCESS_SCOPEZONE_H
+#define NETSNMP_ACCESS_SCOPEZONE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**---------------------------------------------------------------------*/
+/*
+ * structure definitions
+ *
+ *
+ * NOTE: if you add fields, update code dealing with
+ * them in ipv6scopezone_common.c
+ */
+typedef struct netsnmp_v6scopezone_entry_s {
+ netsnmp_index oid_index;
+ oid ns_scopezone_index;
+ u_int ns_flags; /* net-snmp flags */
+ oid index;
+ int scopezone_linklocal;
+
+} netsnmp_v6scopezone_entry;
+
+/**---------------------------------------------------------------------*/
+/*
+ * ACCESS function prototypes
+ */
+
+/*
+ * scopezone container init
+ */
+netsnmp_container * netsnmp_access_scopezone_container_init(u_int init_flags);
+
+/*
+ * scopezone container load and free
+ */
+netsnmp_container*
+netsnmp_access_scopezone_container_load(netsnmp_container* container,
+ u_int load_flags);
+
+void netsnmp_access_scopezone_container_free(netsnmp_container *container,
+ u_int free_flags);
+#define NETSNMP_ACCESS_SCOPEZONE_FREE_NOFLAGS 0x0000
+#define NETSNMP_ACCESS_SCOPEZONE_FREE_DONT_CLEAR 0x0001
+#define NETSNMP_ACCESS_SCOPEZONE_FREE_KEEP_CONTAINER 0x0002
+
+
+/*
+ * create/free an scopezone entry
+ */
+netsnmp_v6scopezone_entry *
+netsnmp_access_scopezone_entry_create(void);
+
+void netsnmp_access_scopezone_entry_free(netsnmp_v6scopezone_entry * entry);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETSNMP_ACCESS_SCOPEZONE_H */
--
1.6.0.2
Reference in New Issue View Git Blame Copy Permalink