ipaddressprefixtable_interface.c

开发snmp的开发包有两个开放的SNMP开发库

    var_ipAddressPrefixIfIndex.type = ASN_INTEGER;
    memset(&var_ipAddressPrefixType, 0x00,
           sizeof(var_ipAddressPrefixType));
    var_ipAddressPrefixType.type = ASN_INTEGER;
    memset(&var_ipAddressPrefixPrefix, 0x00,
           sizeof(var_ipAddressPrefixPrefix));
    var_ipAddressPrefixPrefix.type = ASN_OCTET_STR;
    memset(&var_ipAddressPrefixLength, 0x00,
           sizeof(var_ipAddressPrefixLength));
    var_ipAddressPrefixLength.type = ASN_UNSIGNED;

    /*
     * chain temp index varbinds together
     */
    var_ipAddressPrefixIfIndex.next_variable = &var_ipAddressPrefixType;
    var_ipAddressPrefixType.next_variable = &var_ipAddressPrefixPrefix;
    var_ipAddressPrefixPrefix.next_variable = &var_ipAddressPrefixLength;
    var_ipAddressPrefixLength.next_variable = NULL;


    DEBUGMSGTL(("verbose:ipAddressPrefixTable:ipAddressPrefixTable_index_to_oid", "called\n"));

    /*
     * ipAddressPrefixIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H 
     */
    snmp_set_var_value(&var_ipAddressPrefixIfIndex,
                       (u_char *) & mib_idx->ipAddressPrefixIfIndex,
                       sizeof(mib_idx->ipAddressPrefixIfIndex));

    /*
     * ipAddressPrefixType(2)/InetAddressType/ASN_INTEGER/long(u_long)//l/a/w/E/r/d/h 
     */
    snmp_set_var_value(&var_ipAddressPrefixType,
                       (u_char *) & mib_idx->ipAddressPrefixType,
                       sizeof(mib_idx->ipAddressPrefixType));

    /*
     * ipAddressPrefixPrefix(3)/InetAddress/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h 
     */
    snmp_set_var_value(&var_ipAddressPrefixPrefix,
                       (u_char *) & mib_idx->ipAddressPrefixPrefix,
                       mib_idx->ipAddressPrefixPrefix_len *
                       sizeof(mib_idx->ipAddressPrefixPrefix[0]));

    /*
     * ipAddressPrefixLength(4)/InetAddressPrefixLength/ASN_UNSIGNED/u_long(u_long)//l/a/w/e/R/d/H 
     */
    snmp_set_var_value(&var_ipAddressPrefixLength,
                       (u_char *) & mib_idx->ipAddressPrefixLength,
                       sizeof(mib_idx->ipAddressPrefixLength));


    err = build_oid_noalloc(oid_idx->oids, oid_idx->len, &oid_idx->len,
                            NULL, 0, &var_ipAddressPrefixIfIndex);
    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_ipAddressPrefixIfIndex);

    return err;
}                               /* ipAddressPrefixTable_index_to_oid */

/**
 * extract ipAddressPrefixTable indexes from a netsnmp_index
 *
 * @retval SNMP_ERR_NOERROR  : no error
 * @retval SNMP_ERR_GENERR   : error
 */
int
ipAddressPrefixTable_index_from_oid(netsnmp_index * oid_idx,
                                    ipAddressPrefixTable_mib_index *
                                    mib_idx)
{
    int             err = SNMP_ERR_NOERROR;

    /*
     * temp storage for parsing indexes
     */
    /*
     * ipAddressPrefixIfIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/a/w/e/R/d/H
     */
    netsnmp_variable_list var_ipAddressPrefixIfIndex;
    /*
     * ipAddressPrefixType(2)/InetAddressType/ASN_INTEGER/long(u_long)//l/a/w/E/r/d/h
     */
    netsnmp_variable_list var_ipAddressPrefixType;
    /*
     * ipAddressPrefixPrefix(3)/InetAddress/ASN_OCTET_STR/char(char)//L/a/w/e/R/d/h
     */
    netsnmp_variable_list var_ipAddressPrefixPrefix;
    /*
     * ipAddressPrefixLength(4)/InetAddressPrefixLength/ASN_UNSIGNED/u_long(u_long)//l/a/w/e/R/d/H
     */
    netsnmp_variable_list var_ipAddressPrefixLength;

    /*
     * set up varbinds
     */
    memset(&var_ipAddressPrefixIfIndex, 0x00,
           sizeof(var_ipAddressPrefixIfIndex));
    var_ipAddressPrefixIfIndex.type = ASN_INTEGER;
    memset(&var_ipAddressPrefixType, 0x00,
           sizeof(var_ipAddressPrefixType));
    var_ipAddressPrefixType.type = ASN_INTEGER;
    memset(&var_ipAddressPrefixPrefix, 0x00,
           sizeof(var_ipAddressPrefixPrefix));
    var_ipAddressPrefixPrefix.type = ASN_OCTET_STR;
    memset(&var_ipAddressPrefixLength, 0x00,
           sizeof(var_ipAddressPrefixLength));
    var_ipAddressPrefixLength.type = ASN_UNSIGNED;

    /*
     * chain temp index varbinds together
     */
    var_ipAddressPrefixIfIndex.next_variable = &var_ipAddressPrefixType;
    var_ipAddressPrefixType.next_variable = &var_ipAddressPrefixPrefix;
    var_ipAddressPrefixPrefix.next_variable = &var_ipAddressPrefixLength;
    var_ipAddressPrefixLength.next_variable = NULL;


    DEBUGMSGTL(("verbose:ipAddressPrefixTable:ipAddressPrefixTable_index_from_oid", "called\n"));

    /*
     * parse the oid into the individual index components
     */
    err = parse_oid_indexes(oid_idx->oids, oid_idx->len,
                            &var_ipAddressPrefixIfIndex);
    if (err == SNMP_ERR_NOERROR) {
        /*
         * copy out values
         */
        mib_idx->ipAddressPrefixIfIndex =
            *((long *) var_ipAddressPrefixIfIndex.val.string);
        mib_idx->ipAddressPrefixType =
            *((u_long *) var_ipAddressPrefixType.val.string);
        /*
         * NOTE: val_len is in bytes, ipAddressPrefixPrefix_len might not be
         */
        if (var_ipAddressPrefixPrefix.val_len >
            sizeof(mib_idx->ipAddressPrefixPrefix))
            err = SNMP_ERR_GENERR;
        else {
            memcpy(mib_idx->ipAddressPrefixPrefix,
                   var_ipAddressPrefixPrefix.val.string,
                   var_ipAddressPrefixPrefix.val_len);
            mib_idx->ipAddressPrefixPrefix_len =
                var_ipAddressPrefixPrefix.val_len /
                sizeof(mib_idx->ipAddressPrefixPrefix[0]);
        }
        mib_idx->ipAddressPrefixLength =
            *((u_long *) var_ipAddressPrefixLength.val.string);


    }

    /*
     * parsing may have allocated memory. free it.
     */
    snmp_reset_var_buffers(&var_ipAddressPrefixIfIndex);

    return err;
}                               /* ipAddressPrefixTable_index_from_oid */


/*
 *********************************************************************
 * @internal
 * allocate resources for a ipAddressPrefixTable_rowreq_ctx
 */
ipAddressPrefixTable_rowreq_ctx *
ipAddressPrefixTable_allocate_rowreq_ctx(void *user_init_ctx)
{
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
        SNMP_MALLOC_TYPEDEF(ipAddressPrefixTable_rowreq_ctx);

    DEBUGMSGTL(("internal:ipAddressPrefixTable:ipAddressPrefixTable_allocate_rowreq_ctx", "called\n"));

    if (NULL == rowreq_ctx) {
        snmp_log(LOG_ERR, "Couldn't allocate memory for a "
                 "ipAddressPrefixTable_rowreq_ctx.\n");
        return NULL;
    }

    rowreq_ctx->oid_idx.oids = rowreq_ctx->oid_tmp;

    rowreq_ctx->ipAddressPrefixTable_data_list = NULL;

    /*
     * if we allocated data, call init routine
     */
    if (!(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER)) {
        if (SNMPERR_SUCCESS !=
            ipAddressPrefixTable_rowreq_ctx_init(rowreq_ctx,
                                                 user_init_ctx)) {
            ipAddressPrefixTable_release_rowreq_ctx(rowreq_ctx);
            rowreq_ctx = NULL;
        }
    }

    return rowreq_ctx;
}                               /* ipAddressPrefixTable_allocate_rowreq_ctx */

/*
 * @internal
 * release resources for a ipAddressPrefixTable_rowreq_ctx
 */
void
ipAddressPrefixTable_release_rowreq_ctx(ipAddressPrefixTable_rowreq_ctx *
                                        rowreq_ctx)
{
    DEBUGMSGTL(("internal:ipAddressPrefixTable:ipAddressPrefixTable_release_rowreq_ctx", "called\n"));

    netsnmp_assert(NULL != rowreq_ctx);

    ipAddressPrefixTable_rowreq_ctx_cleanup(rowreq_ctx);

    /*
     * free index oid pointer
     */
    if (rowreq_ctx->oid_idx.oids != rowreq_ctx->oid_tmp)
        free(rowreq_ctx->oid_idx.oids);

    SNMP_FREE(rowreq_ctx);
}                               /* ipAddressPrefixTable_release_rowreq_ctx */

/**
 * @internal
 * wrapper
 */
static int
_mfd_ipAddressPrefixTable_pre_request(netsnmp_mib_handler *handler, netsnmp_handler_registration
                                      *reginfo, netsnmp_agent_request_info
                                      *agtreq_info,
                                      netsnmp_request_info *requests)
{
    int             rc;

    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_pre_request", "called\n"));

    if (1 != netsnmp_row_merge_status_first(reginfo, agtreq_info)) {
        DEBUGMSGTL(("internal:ipAddressPrefixTable",
                    "skipping additional pre_request\n"));
        return SNMP_ERR_NOERROR;
    }

    rc = ipAddressPrefixTable_pre_request(ipAddressPrefixTable_if_ctx.
                                          user_ctx);
    if (MFD_SUCCESS != rc) {
        /*
         * nothing we can do about it but log it
         */
        DEBUGMSGTL(("ipAddressPrefixTable", "error %d from "
                    "ipAddressPrefixTable_pre_request\n", rc));
        netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc));
    }

    return SNMP_ERR_NOERROR;
}                               /* _mfd_ipAddressPrefixTable_pre_request */

/**
 * @internal
 * wrapper
 */
static int
_mfd_ipAddressPrefixTable_post_request(netsnmp_mib_handler *handler, netsnmp_handler_registration
                                       *reginfo, netsnmp_agent_request_info
                                       *agtreq_info,
                                       netsnmp_request_info *requests)
{
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
        netsnmp_container_table_row_extract(requests);
    int             rc, packet_rc;

    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_post_request", "called\n"));

    /*
     * release row context, if deleted
     */
    if (rowreq_ctx && (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED))
        ipAddressPrefixTable_release_rowreq_ctx(rowreq_ctx);

    /*
     * wait for last call before calling user
     */
    if (1 != netsnmp_row_merge_status_last(reginfo, agtreq_info)) {
        DEBUGMSGTL(("internal:ipAddressPrefixTable",
                    "waiting for last post_request\n"));
        return SNMP_ERR_NOERROR;
    }

    packet_rc = netsnmp_check_all_requests_error(agtreq_info->asp, 0);
    rc = ipAddressPrefixTable_post_request(ipAddressPrefixTable_if_ctx.
                                           user_ctx, packet_rc);
    if (MFD_SUCCESS != rc) {
        /*
         * nothing we can do about it but log it
         */
        DEBUGMSGTL(("ipAddressPrefixTable", "error %d from "
                    "ipAddressPrefixTable_post_request\n", rc));
    }

    return SNMP_ERR_NOERROR;
}                               /* _mfd_ipAddressPrefixTable_post_request */

/**
 * @internal
 * wrapper
 */
static int
_mfd_ipAddressPrefixTable_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;
    ipAddressPrefixTable_rowreq_ctx *rowreq_ctx =
        netsnmp_container_table_row_extract(requests);

    DEBUGMSGTL(("internal:ipAddressPrefixTable:_mfd_ipAddressPrefixTable_object_lookup", "called\n"));

    /*
     * get our context from mfd
     * ipAddressPrefixTable_interface_ctx *if_ctx =
     *             (ipAddressPrefixTable_interface_ctx *)reginfo->my_reg_void;
     */

    if (NULL == rowreq_ctx) {
        rc = SNMP_ERR_NOCREATION;
    }

    if (MFD_SUCCESS != rc)
        netsnmp_request_set_error_all(requests, rc);
    else
        ipAddressPrefixTable_row_prep(rowreq_ctx);

    return SNMP_VALIDATE_ERR(rc);
}                               /* _mfd_ipAddressPrefixTable_object_lookup */

/***********************************************************************
 *
 * GET processing
 *
 ***********************************************************************/
/*