/*
 * Note: this file originally auto-generated by mib2c using
 *       version : 1.48 $ of : mfd-top.m2c,v $ 
 *
 * $Id$
 */
/** \page MFD helper for ipv6InterfaceTable
 *
 * \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 "ipv6InterfaceTable.h"

#include <net-snmp/agent/mib_modules.h>

#include "ipv6InterfaceTable_interface.h"

oid             ipv6InterfaceTable_oid[] = { IPV6INTERFACETABLE_OID };
int             ipv6InterfaceTable_oid_size =
OID_LENGTH(ipv6InterfaceTable_oid);

ipv6InterfaceTable_registration ipv6InterfaceTable_user_context;
static ipv6InterfaceTable_registration *ipv6InterfaceTable_user_context_p;

void            initialize_table_ipv6InterfaceTable(void);
void            shutdown_table_ipv6InterfaceTable(void);


/**
 * Initializes the ipv6InterfaceTable module
 */
void
init_ipv6InterfaceTable(void)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:init_ipv6InterfaceTable",
                "called\n"));

    /*
     * TODO:300:o: Perform ipv6InterfaceTable one-time module initialization.
     */

    /*
     * we depend on the ifTable, so we put our init in with it
     * to guarantee order of execution.
     */
    init_ifTable();

    /*
     * last changed should be 0 at startup
     */
    ipv6InterfaceTable_lastChange_set(0);

}                               /* init_ipv6InterfaceTable */

/**
 * Shut-down the ipv6InterfaceTable module (agent is exiting)
 */
void
shutdown_ipv6InterfaceTable(void)
{
    if (should_init("ipv6InterfaceTable"))
        shutdown_table_ipv6InterfaceTable();

}

/**
 * Initialize the table ipv6InterfaceTable 
 *    (Define its contents and how it's structured)
 */
void
initialize_table_ipv6InterfaceTable(void)
{
    u_long          flags;

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:initialize_table_ipv6InterfaceTable", "called\n"));

    /*
     * TODO:301:o: Perform ipv6InterfaceTable one-time table initialization.
     */

    /*
     * TODO:302:o: |->Initialize ipv6InterfaceTable 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.
     */
    ipv6InterfaceTable_user_context_p =
        netsnmp_create_data_list("ipv6InterfaceTable", NULL, NULL);

    /*
     * No support for any flags yet, but in the future you would
     * set any flags here.
     */
    flags = 0;

    /*
     * call interface initialization code
     */
    _ipv6InterfaceTable_initialize_interface
	(ipv6InterfaceTable_user_context_p, flags);
}                               /* initialize_table_ipv6InterfaceTable */

/**
 * Shutdown the table ipv6InterfaceTable 
 */
void
shutdown_table_ipv6InterfaceTable(void)
{
    /*
     * call interface shutdown code
     */
    _ipv6InterfaceTable_shutdown_interface
        (ipv6InterfaceTable_user_context_p);
    netsnmp_free_all_list_data(ipv6InterfaceTable_user_context_p);
    ipv6InterfaceTable_user_context_p = NULL;
}

/**
 * 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
ipv6InterfaceTable_rowreq_ctx_init(ipv6InterfaceTable_rowreq_ctx *
                                   rowreq_ctx, void *user_init_ctx)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_rowreq_ctx_init", "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:210:o: |-> Perform extra ipv6InterfaceTable rowreq initialization. (eg DEFVALS)
     */

    return MFD_SUCCESS;
}                               /* ipv6InterfaceTable_rowreq_ctx_init */

/**
 * extra context cleanup
 * @param rowreq_ctx
 */
void
ipv6InterfaceTable_rowreq_ctx_cleanup(ipv6InterfaceTable_rowreq_ctx *
                                      rowreq_ctx)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_rowreq_ctx_cleanup", "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:211:o: |-> Perform extra ipv6InterfaceTable rowreq cleanup.
     */
}                               /* ipv6InterfaceTable_rowreq_ctx_cleanup */

/**
 * pre-request callback
 *
 * @param user_context
 *
 * @retval MFD_SUCCESS              : success.
 * @retval MFD_ERROR                : other error
 */
int
ipv6InterfaceTable_pre_request(ipv6InterfaceTable_registration *
                               user_context)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_pre_request", "called\n"));

    /*
     * TODO:510:o: Perform ipv6InterfaceTable pre-request actions.
     */

    return MFD_SUCCESS;
}                               /* ipv6InterfaceTable_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
ipv6InterfaceTable_post_request(ipv6InterfaceTable_registration *
                                user_context, int rc)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_post_request", "called\n"));

    /*
     * TODO:511:o: Perform ipv6InterfaceTable post-request actions.
     */

    /*
     * check to set if any rows were changed.
     */
    if (ipv6InterfaceTable_dirty_get()) {
        /*
         * check if request was successful. If so, this would be
         * a good place to save data to its persistent store.
         */
        if (MFD_SUCCESS == rc) {
            /*
             * save changed rows, if you haven't already
             */
        }

        ipv6InterfaceTable_dirty_set(0);        /* clear table dirty flag */
    }

    return MFD_SUCCESS;
}                               /* ipv6InterfaceTable_post_request */


/**********************************************************************
 **********************************************************************
 ***
 *** Table ipv6InterfaceTable
 ***
 **********************************************************************
 **********************************************************************/
/*
 * IP-MIB::ipv6InterfaceTable is subid 30 of ip.
 * Its status is Current.
 * OID: .1.3.6.1.2.1.4.30, length: 8
 */

/*
 * ---------------------------------------------------------------------
 * * TODO:200:r: Implement ipv6InterfaceTable data context functions.
 */


/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceReasmMaxSize
 * ipv6InterfaceReasmMaxSize is subid 2 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadOnly.
 * OID: .1.3.6.1.2.1.4.30.1.2
 * Description:
The size of the largest IPv6 datagram which this entity can
            re-assemble from incoming IPv6 fragmented datagrams received
            on this interface.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  0      hasdefval 0
 *   readable   1     iscolumn 1     ranges 1      hashint   0
 *   settable   0
 *
 * Ranges:  1500 - 65535;
 *
 * Its syntax is UNSIGNED32 (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 ipv6InterfaceReasmMaxSize data.
 *
 * Set a value using the data context for the row.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceReasmMaxSize_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
ipv6InterfaceReasmMaxSize_get(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                              u_long * ipv6InterfaceReasmMaxSize_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipv6InterfaceReasmMaxSize_val_ptr);


    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceReasmMaxSize_get",
                "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    if (!
        (rowreq_ctx->data.ifentry->
         ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_REASMMAX))
        return MFD_SKIP;

    /*
     * TODO:231:o: |-> Extract the current value of the ipv6InterfaceReasmMaxSize data.
     * copy (* ipv6InterfaceReasmMaxSize_val_ptr ) from rowreq_ctx->data
     */
    (*ipv6InterfaceReasmMaxSize_val_ptr) =
        rowreq_ctx->data.ipv6InterfaceReasmMaxSize;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceReasmMaxSize_get */

/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceIdentifier
 * ipv6InterfaceIdentifier is subid 3 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadOnly.
 * OID: .1.3.6.1.2.1.4.30.1.3
 * Description:
The Interface Identifier for this interface.  The Interface
            Identifier is combined with an address prefix to form an
            interface address.


            By default, the Interface Identifier is auto-configured
            according to the rules of the link type this interface is
            attached to.


            A zero length identifier may be used where appropriate.  One
            possible example is a loopback interface.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  0      hasdefval 0
 *   readable   1     iscolumn 1     ranges 1      hashint   1
 *   settable   0
 *   hint: 2x:
 *
 * Ranges:  0 - 8;
 *
 * Its syntax is Ipv6AddressIfIdentifierTC (based on perltype OCTETSTR)
 * The net-snmp type is ASN_OCTET_STR. The C type decl is char (char)
 * This data type requires a length.  (Max 8)
 */
/**
 * Extract the current value of the ipv6InterfaceIdentifier data.
 *
 * Set a value using the data context for the row.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceIdentifier_val_ptr_ptr
 *        Pointer to storage for a char variable
 * @param ipv6InterfaceIdentifier_val_ptr_len_ptr
 *        Pointer to a size_t. On entry, it will contain the size (in bytes)
 *        pointed to by ipv6InterfaceIdentifier.
 *        On exit, this value should contain the data size (in bytes).
 *
 * @retval MFD_SUCCESS         : success
 * @retval MFD_SKIP            : skip this node (no value for now)
 * @retval MFD_ERROR           : Any other error
*
 * @note If you need more than (*ipv6InterfaceIdentifier_val_ptr_len_ptr) bytes of memory,
 *       allocate it using malloc() and update ipv6InterfaceIdentifier_val_ptr_ptr.
 *       <b>DO NOT</b> free the previous pointer.
 *       The MFD helper will release the memory you allocate.
 *
 * @remark If you call this function yourself, you are responsible
 *         for checking if the pointer changed, and freeing any
 *         previously allocated memory. (Not necessary if you pass
 *         in a pointer to static memory, obviously.)
 */
int
ipv6InterfaceIdentifier_get(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                            char **ipv6InterfaceIdentifier_val_ptr_ptr,
                            size_t
                            * ipv6InterfaceIdentifier_val_ptr_len_ptr)
{
   /** we should have a non-NULL pointer and enough storage */
    netsnmp_assert((NULL != ipv6InterfaceIdentifier_val_ptr_ptr)
                   && (NULL != *ipv6InterfaceIdentifier_val_ptr_ptr));
    netsnmp_assert(NULL != ipv6InterfaceIdentifier_val_ptr_len_ptr);


    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceIdentifier_get",
                "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    if (!
        (rowreq_ctx->data.ifentry->
         ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_IFID))
        return MFD_SKIP;

    /*
     * TODO:231:o: |-> Extract the current value of the ipv6InterfaceIdentifier data.
     * copy (* ipv6InterfaceIdentifier_val_ptr_ptr ) data and (* ipv6InterfaceIdentifier_val_ptr_len_ptr ) from rowreq_ctx->data
     */
    /*
     * make sure there is enough space for ipv6InterfaceIdentifier data
     */
    if ((NULL == (*ipv6InterfaceIdentifier_val_ptr_ptr)) ||
        ((*ipv6InterfaceIdentifier_val_ptr_len_ptr) <
         (rowreq_ctx->data.ipv6InterfaceIdentifier_len *
          sizeof(rowreq_ctx->data.ipv6InterfaceIdentifier[0])))) {
        /*
         * allocate space for ipv6InterfaceIdentifier data
         */
        (*ipv6InterfaceIdentifier_val_ptr_ptr) =
            malloc(rowreq_ctx->data.ipv6InterfaceIdentifier_len *
                   sizeof(rowreq_ctx->data.ipv6InterfaceIdentifier[0]));
        if (NULL == (*ipv6InterfaceIdentifier_val_ptr_ptr)) {
            snmp_log(LOG_ERR, "could not allocate memory\n");
            return MFD_ERROR;
        }
    }
    (*ipv6InterfaceIdentifier_val_ptr_len_ptr) =
        rowreq_ctx->data.ipv6InterfaceIdentifier_len *
        sizeof(rowreq_ctx->data.ipv6InterfaceIdentifier[0]);
    memcpy((*ipv6InterfaceIdentifier_val_ptr_ptr),
           rowreq_ctx->data.ipv6InterfaceIdentifier,
           rowreq_ctx->data.ipv6InterfaceIdentifier_len *
           sizeof(rowreq_ctx->data.ipv6InterfaceIdentifier[0]));

    return MFD_SUCCESS;
}                               /* ipv6InterfaceIdentifier_get */

/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceEnableStatus
 * ipv6InterfaceEnableStatus is subid 5 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadWrite.
 * OID: .1.3.6.1.2.1.4.30.1.5
 * Description:
The indication of whether IPv6 is enabled (up) or disabled
            (down) on this interface.  This object does not affect the
            state of the interface itself, only its connection to an
            IPv6 stack.  The IF-MIB should be used to control the state
            of the interface.


            When this object is written the entity SHOULD save the
            change to non-volatile storage and restore the object from
            non-volatile storage upon re-initialization of the system.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  1      hasdefval 0
 *   readable   1     iscolumn 1     ranges 0      hashint   0
 *   settable   1
 *
 * Enum range: 1/8. Values:  up(1), down(2)
 *
 * Its syntax is INTEGER (based on perltype INTEGER)
 * The net-snmp type is ASN_INTEGER. The C type decl is long (u_long)
 */
/**
 * Extract the current value of the ipv6InterfaceEnableStatus data.
 *
 * Set a value using the data context for the row.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceEnableStatus_val_ptr
 *        Pointer to storage for a long variable
 *
 * @retval MFD_SUCCESS         : success
 * @retval MFD_SKIP            : skip this node (no value for now)
 * @retval MFD_ERROR           : Any other error
 */
int
ipv6InterfaceEnableStatus_get(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                              u_long * ipv6InterfaceEnableStatus_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipv6InterfaceEnableStatus_val_ptr);


    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceEnableStatus_get",
                "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:231:o: |-> Extract the current value of the ipv6InterfaceEnableStatus data.
     * copy (* ipv6InterfaceEnableStatus_val_ptr ) from rowreq_ctx->data
     */
    (*ipv6InterfaceEnableStatus_val_ptr) =
        rowreq_ctx->data.ipv6InterfaceEnableStatus;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceEnableStatus_get */

/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceReachableTime
 * ipv6InterfaceReachableTime is subid 6 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadOnly.
 * OID: .1.3.6.1.2.1.4.30.1.6
 * Description:
The time a neighbor is considered reachable after receiving
            a reachability confirmation.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  0      hasdefval 0
 *   readable   1     iscolumn 1     ranges 0      hashint   0
 *   settable   0
 *
 *
 * Its syntax is UNSIGNED32 (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 ipv6InterfaceReachableTime data.
 *
 * Set a value using the data context for the row.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceReachableTime_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
ipv6InterfaceReachableTime_get(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                               u_long * ipv6InterfaceReachableTime_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipv6InterfaceReachableTime_val_ptr);


    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceReachableTime_get", "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    if (!
        (rowreq_ctx->data.ifentry->
         ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_REACHABLE))
        return MFD_SKIP;

    /*
     * TODO:231:o: |-> Extract the current value of the ipv6InterfaceReachableTime data.
     * copy (* ipv6InterfaceReachableTime_val_ptr ) from rowreq_ctx->data
     */
    (*ipv6InterfaceReachableTime_val_ptr) =
        rowreq_ctx->data.ipv6InterfaceReachableTime;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceReachableTime_get */

/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceRetransmitTime
 * ipv6InterfaceRetransmitTime is subid 7 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadOnly.
 * OID: .1.3.6.1.2.1.4.30.1.7
 * Description:
The time between retransmissions of Neighbor Solicitation
            messages to a neighbor when resolving the address or when
            probing the reachability of a neighbor.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  0      hasdefval 0
 *   readable   1     iscolumn 1     ranges 0      hashint   0
 *   settable   0
 *
 *
 * Its syntax is UNSIGNED32 (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 ipv6InterfaceRetransmitTime data.
 *
 * Set a value using the data context for the row.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceRetransmitTime_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
ipv6InterfaceRetransmitTime_get(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                                u_long *
                                ipv6InterfaceRetransmitTime_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipv6InterfaceRetransmitTime_val_ptr);


    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceRetransmitTime_get", "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    if (!
        (rowreq_ctx->data.ifentry->
         ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_RETRANSMIT))
        return MFD_SKIP;

    /*
     * TODO:231:o: |-> Extract the current value of the ipv6InterfaceRetransmitTime data.
     * copy (* ipv6InterfaceRetransmitTime_val_ptr ) from rowreq_ctx->data
     */
    (*ipv6InterfaceRetransmitTime_val_ptr) =
        rowreq_ctx->data.ipv6InterfaceRetransmitTime;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceRetransmitTime_get */

/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceForwarding
 * ipv6InterfaceForwarding is subid 8 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadWrite.
 * OID: .1.3.6.1.2.1.4.30.1.8
 * Description:
The indication of whether this entity is acting as an IPv6
            router on this interface with respect to the forwarding of
            datagrams received by, but not addressed to, this entity.
            IPv6 routers forward datagrams.  IPv6 hosts do not (except
            those source-routed via the host).


            This object is constrained by ipv6IpForwarding and is
            ignored if ipv6IpForwarding is set to notForwarding.  Those
            systems that do not provide per-interface control of the
            forwarding function should set this object to forwarding for
            all interfaces and allow the ipv6IpForwarding object to
            control the forwarding capability.


            When this object is written the entity SHOULD save the
            change to non-volatile storage and restore the object from
            non-volatile storage upon re-initialization of the system.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  1      hasdefval 0
 *   readable   1     iscolumn 1     ranges 0      hashint   0
 *   settable   1
 *
 * Enum range: 2/8. Values:  forwarding(1), notForwarding(2)
 *
 * Its syntax is INTEGER (based on perltype INTEGER)
 * The net-snmp type is ASN_INTEGER. The C type decl is long (u_long)
 */
/**
 * Extract the current value of the ipv6InterfaceForwarding data.
 *
 * Set a value using the data context for the row.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceForwarding_val_ptr
 *        Pointer to storage for a long variable
 *
 * @retval MFD_SUCCESS         : success
 * @retval MFD_SKIP            : skip this node (no value for now)
 * @retval MFD_ERROR           : Any other error
 */
int
ipv6InterfaceForwarding_get(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                            u_long * ipv6InterfaceForwarding_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipv6InterfaceForwarding_val_ptr);


    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceForwarding_get",
                "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    if (!
        (rowreq_ctx->data.ifentry->
         ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_FORWARDING))
        return MFD_SKIP;

    /*
     * TODO:231:o: |-> Extract the current value of the ipv6InterfaceForwarding data.
     * copy (* ipv6InterfaceForwarding_val_ptr ) from rowreq_ctx->data
     */
    (*ipv6InterfaceForwarding_val_ptr) =
        (rowreq_ctx->data.ipv6InterfaceForwarding) ? 1 : 2;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceForwarding_get */


/** @} */
/**********************************************************************
 **********************************************************************
 ***
 *** Table ipv6InterfaceTable
 ***
 **********************************************************************
 **********************************************************************/
/*
 * IP-MIB::ipv6InterfaceTable is subid 30 of ip.
 * Its status is Current.
 * OID: .1.3.6.1.2.1.4.30, length: 8
 */
    /*
     * NOTE: if you update this chart, please update the versions in
     *       local/mib2c-conf.d/parent-set.m2i
     *       agent/mibgroup/helpers/baby_steps.c
     * while you're at it.
     */
    /*
     ***********************************************************************
     * Baby Steps Flow Chart (2004.06.05)                                  *
     *                                                                     *
     * +--------------+    +================+    U = unconditional path    *
     * |optional state|    ||required state||    S = path for success      *
     * +--------------+    +================+    E = path for error        *
     ***********************************************************************
     *
     *                        +--------------+
     *                        |     pre      |
     *                        |   request    |
     *                        +--------------+
     *                               | U
     *                        +==============+
     *       +----------------||  object    ||
     *       |              E ||  lookup    ||
     *       |                +==============+
     *       |                       | S
     *       |                +==============+
     *       |              E ||   check    ||
     *       |<---------------||   values   ||
     *       |                +==============+
     *       |                       | S
     *       |                +==============+
     *       |       +<-------||   undo     ||
     *       |       |      E ||   setup    ||
     *       |       |        +==============+
     *       |       |               | S
     *       |       |        +==============+
     *       |       |        ||    set     ||-------------------------->+
     *       |       |        ||   value    || E                         |
     *       |       |        +==============+                           |
     *       |       |               | S                                 |
     *       |       |        +--------------+                           |
     *       |       |        |    check     |-------------------------->|
     *       |       |        |  consistency | E                         |
     *       |       |        +--------------+                           |
     *       |       |               | S                                 |
     *       |       |        +==============+         +==============+  |
     *       |       |        ||   commit   ||-------->||     undo   ||  |
     *       |       |        ||            || E       ||    commit  ||  |
     *       |       |        +==============+         +==============+  |
     *       |       |               | S                     U |<--------+
     *       |       |        +--------------+         +==============+
     *       |       |        | irreversible |         ||    undo    ||
     *       |       |        |    commit    |         ||     set    ||
     *       |       |        +--------------+         +==============+
     *       |       |               | U                     U |
     *       |       +-------------->|<------------------------+
     *       |                +==============+
     *       |                ||   undo     ||
     *       |                ||  cleanup   ||
     *       |                +==============+
     *       +---------------------->| U
     *                        +--------------+
     *                        |    post      |
     *                        |   request    |
     *                        +--------------+
     *
     */

/**
 * Setup up context with information needed to undo a set request.
 *
 * This function will be called before the individual node undo setup
 * functions are called. If you need to do any undo setup that is not
 * related to a specific column, you can do it here.
 *
 * Note that the undo context has been allocated with
 * ipv6InterfaceTable_allocate_data(), but may need extra
 * initialization similar to what you may have done in
 * ipv6InterfaceTable_rowreq_ctx_init().
 * Note that an individual node's undo_setup function will only be called
 * if that node is being set to a new value.
 *
 * If there is any setup specific to a particular column (e.g. allocating
 * memory for a string), you should do that setup in the node's undo_setup
 * function, so it won't be done unless it is necessary.
 *
 * @param rowreq_ctx
 *        Pointer to the table context (ipv6InterfaceTable_rowreq_ctx)
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error. set will fail.
 */
int
ipv6InterfaceTable_undo_setup(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{
    int             rc = MFD_SUCCESS;

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_undo_setup",
                "called\n"));

    /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:451:M: |-> Setup ipv6InterfaceTable undo.
     * set up ipv6InterfaceTable undo information, in preparation for a set.
     * Undo storage is in (* ipv6InterfaceForwarding_val_ptr )*
     */

    return rc;
}                               /* ipv6InterfaceTable_undo_setup */

/**
 * Undo a set request.
 *
 * This function will be called before the individual node undo
 * functions are called. If you need to do any undo that is not
 * related to a specific column, you can do it here.
 *
 * Note that an individual node's undo function will only be called
 * if that node is being set to a new value.
 *
 * If there is anything  specific to a particular column (e.g. releasing
 * memory for a string), you should do that setup in the node's undo
 * function, so it won't be done unless it is necessary.
 *
 * @param rowreq_ctx
 *        Pointer to the table context (ipv6InterfaceTable_rowreq_ctx)
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error. set will fail.
 */
int
ipv6InterfaceTable_undo(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{
    int             rc = MFD_SUCCESS;

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_undo",
                "called\n"));

    /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:451:M: |-> ipv6InterfaceTable undo.
     * ipv6InterfaceTable undo information, in response to a failed set.
     * Undo storage is in (* ipv6InterfaceForwarding_val_ptr )*
     */

    return rc;
}                               /* ipv6InterfaceTable_undo_setup */

/**
 * Cleanup up context undo information.
 *
 * This function will be called after set/commit processing. If you
 * allocated any resources in undo_setup, this is the place to release
 * those resources.
 *
 * This function is called regardless of the success or failure of the set
 * request. If you need to perform different steps for cleanup depending
 * on success or failure, you can add a flag to the rowreq_ctx.
 *
 * @param rowreq_ctx
 *        Pointer to the table context (ipv6InterfaceTable_rowreq_ctx)
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error
 */
int
ipv6InterfaceTable_undo_cleanup(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{
    int             rc = MFD_SUCCESS;

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_undo_cleanup", "called\n"));

    /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:452:M: |-> Cleanup ipv6InterfaceTable undo.
     * Undo storage is in (* ipv6InterfaceForwarding_val_ptr )*
     */

    return rc;
}                               /* ipv6InterfaceTable_undo_cleanup */

/**
 * commit new values.
 *
 * At this point, you should have done everything you can to ensure that
 * this commit will not fail.
 *
 * Should you need different behavior depending on which columns were
 * set, rowreq_ctx->column_set_flags will indicate which writeable columns were
 * set. The definitions for the COLUMN_*_FLAG bits can be found in
 * ipv6InterfaceTable.h.
 * A new row will have the MFD_ROW_CREATED bit set in rowreq_flags.
 *
 * @param rowreq_ctx
 *        Pointer to the users context.
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error
 */
int
ipv6InterfaceTable_commit(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{
    int             rc = MFD_SUCCESS;
    int             save_flags;

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_commit",
                "called\n"));

    /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * save flags, then clear until we actually do something
     */
    save_flags = rowreq_ctx->column_set_flags;
    rowreq_ctx->column_set_flags = 0;

    /*
     * commit ipv6InterfaceTable data
     * 1) check the column's flag in save_flags to see if it was set.
     * 2) clear the flag when you handle that column
     * 3) set the column's flag in column_set_flags if it needs undo
     *    processing in case of a failure.
     */
    if (save_flags & COLUMN_IPV6INTERFACEENABLESTATUS_FLAG) {
        save_flags &= ~COLUMN_IPV6INTERFACEENABLESTATUS_FLAG;   /* clear ipv6InterfaceEnableStatus */
        /*
         * TODO:482:o: |-> commit column ipv6InterfaceEnableStatus.
         */
        rc = -1;
        if (-1 == rc) {
            snmp_log(LOG_ERR,
                     "ipv6InterfaceTable column ipv6InterfaceEnableStatus commit failed\n");
        } else {
            /*
             * set flag, in case we need to undo ipv6InterfaceEnableStatus
             */
            rowreq_ctx->column_set_flags |=
                COLUMN_IPV6INTERFACEENABLESTATUS_FLAG;
        }
    }

    if (save_flags & COLUMN_IPV6INTERFACEFORWARDING_FLAG) {
        save_flags &= ~COLUMN_IPV6INTERFACEFORWARDING_FLAG;     /* clear ipv6InterfaceForwarding */
        /*
         * TODO:482:o: |-> commit column ipv6InterfaceForwarding.
         */
        rc = -1;
        if (-1 == rc) {
            snmp_log(LOG_ERR,
                     "ipv6InterfaceTable column ipv6InterfaceForwarding commit failed\n");
        } else {
            /*
             * set flag, in case we need to undo ipv6InterfaceForwarding
             */
            rowreq_ctx->column_set_flags |=
                COLUMN_IPV6INTERFACEFORWARDING_FLAG;
        }
    }

    /*
     * if we successfully commited this row, set the dirty flag.
     */
    if (MFD_SUCCESS == rc) {
        rowreq_ctx->rowreq_flags |= MFD_ROW_DIRTY;
    }

    if (save_flags) {
        snmp_log(LOG_ERR, "unhandled columns (0x%x) in commit\n",
                 save_flags);
        return MFD_ERROR;
    }

    return rc;
}                               /* ipv6InterfaceTable_commit */

/**
 * undo commit new values.
 *
 * Should you need different behavior depending on which columns were
 * set, rowreq_ctx->column_set_flags will indicate which writeable columns were
 * set. The definitions for the COLUMN_*_FLAG bits can be found in
 * ipv6InterfaceTable.h.
 * A new row will have the MFD_ROW_CREATED bit set in rowreq_flags.
 *
 * @param rowreq_ctx
 *        Pointer to the users context.
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error
 */
int
ipv6InterfaceTable_undo_commit(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{
    int             rc = MFD_SUCCESS;

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceTable_undo_commit", "called\n"));

    /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:485:M: |-> Undo ipv6InterfaceTable commit.
     * check the column's flag in rowreq_ctx->column_set_flags to see
     * if it was set during commit, then undo it.
     *
     * eg: if (rowreq_ctx->column_set_flags & COLUMN__FLAG) {}
     */


    /*
     * if we successfully un-commited this row, clear the dirty flag.
     */
    if (MFD_SUCCESS == rc) {
        rowreq_ctx->rowreq_flags &= ~MFD_ROW_DIRTY;
    }

    return rc;
}                               /* ipv6InterfaceTable_undo_commit */

/*
 * TODO:440:M: Implement ipv6InterfaceTable node value checks.
 * TODO:450:M: Implement ipv6InterfaceTable undo functions.
 * TODO:460:M: Implement ipv6InterfaceTable set functions.
 * TODO:480:M: Implement ipv6InterfaceTable commit functions.
 */
/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceEnableStatus
 * ipv6InterfaceEnableStatus is subid 5 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadWrite.
 * OID: .1.3.6.1.2.1.4.30.1.5
 * Description:
The indication of whether IPv6 is enabled (up) or disabled
            (down) on this interface.  This object does not affect the
            state of the interface itself, only its connection to an
            IPv6 stack.  The IF-MIB should be used to control the state
            of the interface.


            When this object is written the entity SHOULD save the
            change to non-volatile storage and restore the object from
            non-volatile storage upon re-initialization of the system.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  1      hasdefval 0
 *   readable   1     iscolumn 1     ranges 0      hashint   0
 *   settable   1
 *
 * Enum range: 1/8. Values:  up(1), down(2)
 *
 * Its syntax is INTEGER (based on perltype INTEGER)
 * The net-snmp type is ASN_INTEGER. The C type decl is long (u_long)
 */
/**
 * Check that the proposed new value is potentially valid.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceEnableStatus_val
 *        A long containing the new value.
 *
 * @retval MFD_SUCCESS        : incoming value is legal
 * @retval MFD_NOT_VALID_NOW  : incoming value is not valid now
 * @retval MFD_NOT_VALID_EVER : incoming value is never valid
 *
 * This is the place to check for requirements that are not
 * expressed in the mib syntax (for example, a requirement that
 * is detailed in the description for an object).
 *
 * You should check that the requested change between the undo value and the
 * new value is legal (ie, the transistion from one value to another
 * is legal).
 *      
 *@note
 * This check is only to determine if the new value
 * is \b potentially valid. This is the first check of many, and
 * is one of the simplest ones.
 * 
 *@note
 * this is not the place to do any checks for values
 * which depend on some other value in the mib. Those
 * types of checks should be done in the
 * ipv6InterfaceTable_check_dependencies() function.
 *
 * The following checks have already been done for you:
 *    The syntax is ASN_INTEGER
 *    The value is one of  up(1), down(2)
 *
 * If there a no other checks you need to do, simply return MFD_SUCCESS.
 *
 */
int
ipv6InterfaceEnableStatus_check_value(ipv6InterfaceTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long ipv6InterfaceEnableStatus_val)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceEnableStatus_check_value", "called\n"));

    /** should never get a NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:441:o: |-> Check for valid ipv6InterfaceEnableStatus value.
     */

    return MFD_SUCCESS;         /* ipv6InterfaceEnableStatus value not illegal */
}                               /* ipv6InterfaceEnableStatus_check_value */

/**
 * Save old value information
 *
 * @param rowreq_ctx
 *        Pointer to the table context (ipv6InterfaceTable_rowreq_ctx)
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error. set will fail.
 *
 * This function will be called after the table level undo setup function
 * ipv6InterfaceTable_undo_setup has been called.
 *
 *@note
 * this function will only be called if a new value is set for this column.
 *
 * If there is any setup specific to a particular column (e.g. allocating
 * memory for a string), you should do that setup in this function, so it
 * won't be done unless it is necessary.
 */
int
ipv6InterfaceEnableStatus_undo_setup(ipv6InterfaceTable_rowreq_ctx *
                                     rowreq_ctx)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceEnableStatus_undo_setup", "called\n"));

    /** should never get a NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:455:o: |-> Setup ipv6InterfaceEnableStatus undo.
     */
    /*
     * copy ipv6InterfaceEnableStatus data
     * set rowreq_ctx->undo->ipv6InterfaceEnableStatus from rowreq_ctx->data.ipv6InterfaceEnableStatus
     */
    rowreq_ctx->undo->ipv6InterfaceEnableStatus =
        rowreq_ctx->data.ipv6InterfaceEnableStatus;


    return MFD_SUCCESS;
}                               /* ipv6InterfaceEnableStatus_undo_setup */

/**
 * Set the new value.
 *
 * @param rowreq_ctx
 *        Pointer to the users context. You should know how to
 *        manipulate the value from this object.
 * @param ipv6InterfaceEnableStatus_val
 *        A long containing the new value.
 */
int
ipv6InterfaceEnableStatus_set(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                              u_long ipv6InterfaceEnableStatus_val)
{

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceEnableStatus_set",
                "called\n"));

    /** should never get a NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:461:M: |-> Set ipv6InterfaceEnableStatus value.
     * set ipv6InterfaceEnableStatus value in rowreq_ctx->data
     */
    rowreq_ctx->data.ipv6InterfaceEnableStatus =
        ipv6InterfaceEnableStatus_val;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceEnableStatus_set */

/**
 * undo the previous set.
 *
 * @param rowreq_ctx
 *        Pointer to the users context.
 */
int
ipv6InterfaceEnableStatus_undo(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceEnableStatus_undo", "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:456:o: |-> Clean up ipv6InterfaceEnableStatus undo.
     */
    /*
     * copy ipv6InterfaceEnableStatus data
     * set rowreq_ctx->data.ipv6InterfaceEnableStatus from rowreq_ctx->undo->ipv6InterfaceEnableStatus
     */
    rowreq_ctx->data.ipv6InterfaceEnableStatus =
        rowreq_ctx->undo->ipv6InterfaceEnableStatus;


    return MFD_SUCCESS;
}                               /* ipv6InterfaceEnableStatus_undo */

/*---------------------------------------------------------------------
 * IP-MIB::ipv6InterfaceEntry.ipv6InterfaceForwarding
 * ipv6InterfaceForwarding is subid 8 of ipv6InterfaceEntry.
 * Its status is Current, and its access level is ReadWrite.
 * OID: .1.3.6.1.2.1.4.30.1.8
 * Description:
The indication of whether this entity is acting as an IPv6
            router on this interface with respect to the forwarding of
            datagrams received by, but not addressed to, this entity.
            IPv6 routers forward datagrams.  IPv6 hosts do not (except
            those source-routed via the host).


            This object is constrained by ipv6IpForwarding and is
            ignored if ipv6IpForwarding is set to notForwarding.  Those
            systems that do not provide per-interface control of the
            forwarding function should set this object to forwarding for
            all interfaces and allow the ipv6IpForwarding object to
            control the forwarding capability.


            When this object is written the entity SHOULD save the
            change to non-volatile storage and restore the object from
            non-volatile storage upon re-initialization of the system.
 *
 * Attributes:
 *   accessible 1     isscalar 0     enums  1      hasdefval 0
 *   readable   1     iscolumn 1     ranges 0      hashint   0
 *   settable   1
 *
 * Enum range: 2/8. Values:  forwarding(1), notForwarding(2)
 *
 * Its syntax is INTEGER (based on perltype INTEGER)
 * The net-snmp type is ASN_INTEGER. The C type decl is long (u_long)
 */
/**
 * Check that the proposed new value is potentially valid.
 *
 * @param rowreq_ctx
 *        Pointer to the row request context.
 * @param ipv6InterfaceForwarding_val
 *        A long containing the new value.
 *
 * @retval MFD_SUCCESS        : incoming value is legal
 * @retval MFD_NOT_VALID_NOW  : incoming value is not valid now
 * @retval MFD_NOT_VALID_EVER : incoming value is never valid
 *
 * This is the place to check for requirements that are not
 * expressed in the mib syntax (for example, a requirement that
 * is detailed in the description for an object).
 *
 * You should check that the requested change between the undo value and the
 * new value is legal (ie, the transistion from one value to another
 * is legal).
 *      
 *@note
 * This check is only to determine if the new value
 * is \b potentially valid. This is the first check of many, and
 * is one of the simplest ones.
 * 
 *@note
 * this is not the place to do any checks for values
 * which depend on some other value in the mib. Those
 * types of checks should be done in the
 * ipv6InterfaceTable_check_dependencies() function.
 *
 * The following checks have already been done for you:
 *    The syntax is ASN_INTEGER
 *    The value is one of  forwarding(1), notForwarding(2)
 *
 * If there a no other checks you need to do, simply return MFD_SUCCESS.
 *
 */
int
ipv6InterfaceForwarding_check_value(ipv6InterfaceTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long ipv6InterfaceForwarding_val)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceForwarding_check_value", "called\n"));

    /** should never get a NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:441:o: |-> Check for valid ipv6InterfaceForwarding value.
     */

    return MFD_SUCCESS;         /* ipv6InterfaceForwarding value not illegal */
}                               /* ipv6InterfaceForwarding_check_value */

/**
 * Save old value information
 *
 * @param rowreq_ctx
 *        Pointer to the table context (ipv6InterfaceTable_rowreq_ctx)
 *
 * @retval MFD_SUCCESS : success
 * @retval MFD_ERROR   : error. set will fail.
 *
 * This function will be called after the table level undo setup function
 * ipv6InterfaceTable_undo_setup has been called.
 *
 *@note
 * this function will only be called if a new value is set for this column.
 *
 * If there is any setup specific to a particular column (e.g. allocating
 * memory for a string), you should do that setup in this function, so it
 * won't be done unless it is necessary.
 */
int
ipv6InterfaceForwarding_undo_setup(ipv6InterfaceTable_rowreq_ctx *
                                   rowreq_ctx)
{
    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceForwarding_undo_setup", "called\n"));

    /** should never get a NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:455:o: |-> Setup ipv6InterfaceForwarding undo.
     */
    /*
     * copy ipv6InterfaceForwarding data
     * set rowreq_ctx->undo->ipv6InterfaceForwarding from rowreq_ctx->data.ipv6InterfaceForwarding
     */
    rowreq_ctx->undo->ipv6InterfaceForwarding =
        rowreq_ctx->data.ipv6InterfaceForwarding;


    return MFD_SUCCESS;
}                               /* ipv6InterfaceForwarding_undo_setup */

/**
 * Set the new value.
 *
 * @param rowreq_ctx
 *        Pointer to the users context. You should know how to
 *        manipulate the value from this object.
 * @param ipv6InterfaceForwarding_val
 *        A long containing the new value.
 */
int
ipv6InterfaceForwarding_set(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx,
                            u_long ipv6InterfaceForwarding_val)
{

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceForwarding_set",
                "called\n"));

    /** should never get a NULL pointer */
    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:461:M: |-> Set ipv6InterfaceForwarding value.
     * set ipv6InterfaceForwarding value in rowreq_ctx->data
     */
    rowreq_ctx->data.ipv6InterfaceForwarding = ipv6InterfaceForwarding_val;

    return MFD_SUCCESS;
}                               /* ipv6InterfaceForwarding_set */

/**
 * undo the previous set.
 *
 * @param rowreq_ctx
 *        Pointer to the users context.
 */
int
ipv6InterfaceForwarding_undo(ipv6InterfaceTable_rowreq_ctx * rowreq_ctx)
{

    DEBUGMSGTL(("verbose:ipv6InterfaceTable:ipv6InterfaceForwarding_undo",
                "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    /*
     * TODO:456:o: |-> Clean up ipv6InterfaceForwarding undo.
     */
    /*
     * copy ipv6InterfaceForwarding data
     * set rowreq_ctx->data.ipv6InterfaceForwarding from rowreq_ctx->undo->ipv6InterfaceForwarding
     */
    rowreq_ctx->data.ipv6InterfaceForwarding =
        rowreq_ctx->undo->ipv6InterfaceForwarding;


    return MFD_SUCCESS;
}                               /* ipv6InterfaceForwarding_undo */

/** @} */
/** @{ */