Search
j0ke.net Open Build Service
>
Projects
>
GFS
>
net-snmp
> Add-IPv6-Scope-Zone-Index.patch
Sign Up
|
Log In
Username
Password
Cancel
Overview
Repositories
Revisions
Requests
Users
Advanced
Attributes
Meta
File Add-IPv6-Scope-Zone-Index.patch of Package net-snmp (Revision 3)
Currently displaying revision
3
,
show latest
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
