ifxtable_interface.c

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

{
    int             err = SNMP_ERR_NOERROR;

    /*
     * temp storage for parsing indexes
     */
    /*
     * ifIndex(1)/InterfaceIndex/ASN_INTEGER/long(long)//l/A/w/e/R/d/H
     */
    netsnmp_variable_list var_ifIndex;

    /*
     * set up varbinds
     */
    memset(&var_ifIndex, 0x00, sizeof(var_ifIndex));
    var_ifIndex.type = ASN_INTEGER;

    /*
     * chain temp index varbinds together
     */
    var_ifIndex.next_variable = NULL;


    DEBUGMSGTL(("verbose:ifXTable:ifXTable_index_from_oid", "called\n"));

    /*
     * parse the oid into the individual index components
     */
    err = parse_oid_indexes(oid_idx->oids, oid_idx->len, &var_ifIndex);
    if (err == SNMP_ERR_NOERROR) {
        /*
         * copy out values
         */
        mib_idx->ifIndex = *((long *) var_ifIndex.val.string);


    }

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

    return err;
}                               /* ifXTable_index_from_oid */


/*
 * ifXTable_allocate_data
 *
 * Purpose: create new ifXTable_data.
 */
ifXTable_data  *
ifXTable_allocate_data(void)
{
    ifXTable_data  *rtn = SNMP_MALLOC_TYPEDEF(ifXTable_data);

    DEBUGMSGTL(("verbose:ifXTable:ifXTable_allocate_data", "called\n"));

    if (NULL == rtn) {
        snmp_log(LOG_ERR, "unable to malloc memory for new "
                 "ifXTable_data.\n");
    }

    return rtn;
}                               /* ifXTable_allocate_data */

/*
 * ifXTable_release_data
 *
 * Purpose: release ifXTable data.
 */
void
ifXTable_release_data(ifXTable_data * data)
{
    DEBUGMSGTL(("verbose:ifXTable:ifXTable_release_data", "called\n"));

    free(data);
}                               /* ifXTable_release_data */

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

    DEBUGMSGTL(("internal:ifXTable:_mfd_ifXTable_pre_request",
                "called\n"));

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

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

    return SNMP_ERR_NOERROR;
}                               /* _mfd_ifXTable_pre_request */

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

    DEBUGMSGTL(("internal:ifXTable:_mfd_ifXTable_post_request",
                "called\n"));

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

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

    packet_rc = netsnmp_check_all_requests_error(agtreq_info->asp, 0);
    if ((MFD_SUCCESS != packet_rc) && ifXTable_dirty_get()) {
        /*
         * we shouldn't get here. the undo steps should also clear
         * the dirty flags.
         */
        snmp_log(LOG_WARNING, "ifXTable dirty flag set in post_request "
                 "but status != SUCCESS.\n");
    }

    rc = ifXTable_post_request(ifXTable_if_ctx.user_ctx, packet_rc);
    if (MFD_SUCCESS != rc) {
        /*
         * nothing we can do about it but log it
         */
        DEBUGMSGTL(("ifXTable", "error %d from "
                    "ifXTable_post_request\n", rc));
    }

    return SNMP_ERR_NOERROR;
}                               /* _mfd_ifXTable_post_request */

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

    DEBUGMSGTL(("internal:ifXTable:_mfd_ifXTable_object_lookup",
                "called\n"));

    /*
     * get our context from mfd
     * ifXTable_interface_ctx *if_ctx =
     *             (ifXTable_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
        ifXTable_row_prep(rowreq_ctx);

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

/***********************************************************************
 *
 * GET processing
 *
 ***********************************************************************/
/*
 * @internal
 * Retrieve the value for a particular column
 */
NETSNMP_STATIC_INLINE int
_ifXTable_get_column(ifXTable_rowreq_ctx * rowreq_ctx,
                     netsnmp_variable_list * var, int column)
{
    int             rc = SNMPERR_SUCCESS;

    DEBUGMSGTL(("internal:ifXTable:_mfd_ifXTable_get_column",
                "called for %d\n", column));


    netsnmp_assert(NULL != rowreq_ctx);

    switch (column) {

        /*
         * ifName(1)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H 
         */
    case COLUMN_IFNAME:
        var->type = ASN_OCTET_STR;
        rc = ifName_get(rowreq_ctx, (char **) &var->val.string,
                        &var->val_len);
        break;

        /*
         * ifInMulticastPkts(2)/COUNTER/ASN_COUNTER/u_long(u_long)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFINMULTICASTPKTS:
        var->val_len = sizeof(u_long);
        var->type = ASN_COUNTER;
        rc = ifInMulticastPkts_get(rowreq_ctx, (u_long *) var->val.string);
        break;

        /*
         * ifInBroadcastPkts(3)/COUNTER/ASN_COUNTER/u_long(u_long)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFINBROADCASTPKTS:
        var->val_len = sizeof(u_long);
        var->type = ASN_COUNTER;
        rc = ifInBroadcastPkts_get(rowreq_ctx, (u_long *) var->val.string);
        break;

        /*
         * ifOutMulticastPkts(4)/COUNTER/ASN_COUNTER/u_long(u_long)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFOUTMULTICASTPKTS:
        var->val_len = sizeof(u_long);
        var->type = ASN_COUNTER;
        rc = ifOutMulticastPkts_get(rowreq_ctx,
                                    (u_long *) var->val.string);
        break;

        /*
         * ifOutBroadcastPkts(5)/COUNTER/ASN_COUNTER/u_long(u_long)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFOUTBROADCASTPKTS:
        var->val_len = sizeof(u_long);
        var->type = ASN_COUNTER;
        rc = ifOutBroadcastPkts_get(rowreq_ctx,
                                    (u_long *) var->val.string);
        break;

        /*
         * ifHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCINOCTETS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCInOctets_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCInUcastPkts(7)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCINUCASTPKTS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCInUcastPkts_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCInMulticastPkts(8)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCINMULTICASTPKTS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCInMulticastPkts_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCInBroadcastPkts(9)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCINBROADCASTPKTS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCInBroadcastPkts_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCOutOctets(10)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCOUTOCTETS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutOctets_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCOutUcastPkts(11)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCOUTUCASTPKTS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutUcastPkts_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCOutMulticastPkts(12)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCOUTMULTICASTPKTS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutMulticastPkts_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifHCOutBroadcastPkts(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCOUTBROADCASTPKTS:
        var->val_len = sizeof(U64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutBroadcastPkts_get(rowreq_ctx, (U64 *) var->val.string);
        break;

        /*
         * ifLinkUpDownTrapEnable(14)/INTEGER/ASN_INTEGER/long(u_long)//l/A/W/E/r/d/h 
         */
    case COLUMN_IFLINKUPDOWNTRAPENABLE:
        var->val_len = sizeof(u_long);
        var->type = ASN_INTEGER;
        rc = ifLinkUpDownTrapEnable_get(rowreq_ctx,
                                        (u_long *) var->val.string);
        break;

        /*
         * ifHighSpeed(15)/GAUGE/ASN_GAUGE/u_long(u_long)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHIGHSPEED:
        var->val_len = sizeof(u_long);
        var->type = ASN_GAUGE;
        rc = ifHighSpeed_get(rowreq_ctx, (u_long *) var->val.string);
        break;

        /*
         * ifPromiscuousMode(16)/TruthValue/ASN_INTEGER/long(u_long)//l/A/W/E/r/d/h 
         */
    case COLUMN_IFPROMISCUOUSMODE:
        var->val_len = sizeof(u_long);
        var->type = ASN_INTEGER;
        rc = ifPromiscuousMode_get(rowreq_ctx, (u_long *) var->val.string);
        break;

        /*
         * ifConnectorPresent(17)/TruthValue/ASN_INTEGER/long(u_long)//l/A/w/E/r/d/h 
         */
    case COLUMN_IFCONNECTORPRESENT:
        var->val_len = sizeof(u_long);
        var->type = ASN_INTEGER;
        rc = ifConnectorPresent_get(rowreq_ctx,
                                    (u_long *) var->val.string);
        break;

        /*
         * ifAlias(18)/DisplayString/ASN_OCTET_STR/char(char)//L/A/W/e/R/d/H 
         */
    case COLUMN_IFALIAS:
        var->type = ASN_OCTET_STR;
        rc = ifAlias_get(rowreq_ctx, (char **) &var->val.string,
                         &var->val_len);
        break;

        /*
         * ifCounterDiscontinuityTime(19)/TimeStamp/ASN_TIMETICKS/u_long(u_long)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFCOUNTERDISCONTINUITYTIME:
        var->val_len = sizeof(u_long);
        var->type = ASN_TIMETICKS;
        rc = ifCounterDiscontinuityTime_get(rowreq_ctx,
                                            (u_long *) var->val.string);
        break;

    default:
        snmp_log(LOG_ERR, "unknown column %d in _ifXTable_get_column\n",
                 column);
        break;
    }

    return rc;
}                               /* _ifXTable_get_column */

int
_mfd_ifXTable_get_values(netsnmp_mib_handler *handler,
                         netsnmp_handler_registration *reginfo,
                         netsnmp_agent_request_info *agtreq_info,
                         netsnmp_request_info *requests)
{
    ifXTable_rowreq_ctx *rowreq_ctx =
        netsnmp_container_table_row_extract(requests);
    netsnmp_table_request_info *tri;
    u_char         *old_string;