Attachment #434368 for bug #582368




 */
int
ifHCInOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
                 struct counter64 *ifHCInOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCInOctets_val_ptr);

 */
int
ifHCInUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                    struct counter64 *ifHCInUcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCInUcastPkts_val_ptr);

 */
int
ifHCInMulticastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                        struct counter64 *ifHCInMulticastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCInMulticastPkts_val_ptr);

 */
int
ifHCInBroadcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                        struct counter64 *ifHCInBroadcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCInBroadcastPkts_val_ptr);

 */
int
ifHCOutOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
                  struct counter64 *ifHCOutOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCOutOctets_val_ptr);

 */
int
ifHCOutUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                     struct counter64 *ifHCOutUcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCOutUcastPkts_val_ptr);

 */
int
ifHCOutMulticastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                         struct counter64 *ifHCOutMulticastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCOutMulticastPkts_val_ptr);

 */
int
ifHCOutBroadcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                         struct counter64 *ifHCOutBroadcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ifHCOutBroadcastPkts_val_ptr);




                                           u_long *
                                           ifOutBroadcastPkts_val_ptr);
    int             ifHCInOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
                                     struct counter64 *ifHCInOctets_val_ptr);
    int             ifHCInUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                                        struct counter64 *ifHCInUcastPkts_val_ptr);
    int             ifHCInMulticastPkts_get(ifXTable_rowreq_ctx *
                                            rowreq_ctx,
                                            struct counter64 *
                                            ifHCInMulticastPkts_val_ptr);
    int             ifHCInBroadcastPkts_get(ifXTable_rowreq_ctx *
                                            rowreq_ctx,
                                            struct counter64 *
                                            ifHCInBroadcastPkts_val_ptr);
    int             ifHCOutOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
                                      struct counter64 *ifHCOutOctets_val_ptr);
    int             ifHCOutUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
                                         struct counter64 *ifHCOutUcastPkts_val_ptr);
    int             ifHCOutMulticastPkts_get(ifXTable_rowreq_ctx *
                                             rowreq_ctx,
                                             struct counter64 *
                                             ifHCOutMulticastPkts_val_ptr);
    int             ifHCOutBroadcastPkts_get(ifXTable_rowreq_ctx *
                                             rowreq_ctx,
                                             struct counter64 *
                                             ifHCOutBroadcastPkts_val_ptr);
    int             ifLinkUpDownTrapEnable_get(ifXTable_rowreq_ctx *
                                               rowreq_ctx,


    int             ifHCInOctets_check_value(ifXTable_rowreq_ctx *
                                             rowreq_ctx,
                                             struct counter64 ifHCInOctets_val);
    int             ifHCInOctets_undo_setup(ifXTable_rowreq_ctx *
                                            rowreq_ctx);
    int             ifHCInOctets_set(ifXTable_rowreq_ctx * rowreq_ctx,
                                     struct counter64 ifHCInOctets_val);
    int             ifHCInOctets_undo(ifXTable_rowreq_ctx * rowreq_ctx);

    int             ifHCInUcastPkts_check_value(ifXTable_rowreq_ctx *
                                                rowreq_ctx,
                                                struct counter64 ifHCInUcastPkts_val);
    int             ifHCInUcastPkts_undo_setup(ifXTable_rowreq_ctx *
                                               rowreq_ctx);
    int             ifHCInUcastPkts_set(ifXTable_rowreq_ctx * rowreq_ctx,
                                        struct counter64 ifHCInUcastPkts_val);
    int             ifHCInUcastPkts_undo(ifXTable_rowreq_ctx * rowreq_ctx);

    int             ifHCInMulticastPkts_check_value(ifXTable_rowreq_ctx *
                                                    rowreq_ctx,
                                                    struct counter64
                                                    ifHCInMulticastPkts_val);
    int             ifHCInMulticastPkts_undo_setup(ifXTable_rowreq_ctx *
                                                   rowreq_ctx);
    int             ifHCInMulticastPkts_set(ifXTable_rowreq_ctx *
                                            rowreq_ctx,
                                            struct counter64 ifHCInMulticastPkts_val);
    int             ifHCInMulticastPkts_undo(ifXTable_rowreq_ctx *
                                             rowreq_ctx);

    int             ifHCInBroadcastPkts_check_value(ifXTable_rowreq_ctx *
                                                    rowreq_ctx,
                                                    struct counter64
                                                    ifHCInBroadcastPkts_val);
    int             ifHCInBroadcastPkts_undo_setup(ifXTable_rowreq_ctx *
                                                   rowreq_ctx);
    int             ifHCInBroadcastPkts_set(ifXTable_rowreq_ctx *
                                            rowreq_ctx,
                                            struct counter64 ifHCInBroadcastPkts_val);
    int             ifHCInBroadcastPkts_undo(ifXTable_rowreq_ctx *
                                             rowreq_ctx);

    int             ifHCOutOctets_check_value(ifXTable_rowreq_ctx *
                                              rowreq_ctx,
                                              struct counter64 ifHCOutOctets_val);
    int             ifHCOutOctets_undo_setup(ifXTable_rowreq_ctx *
                                             rowreq_ctx);
    int             ifHCOutOctets_set(ifXTable_rowreq_ctx * rowreq_ctx,
                                      struct counter64 ifHCOutOctets_val);
    int             ifHCOutOctets_undo(ifXTable_rowreq_ctx * rowreq_ctx);

    int             ifHCOutUcastPkts_check_value(ifXTable_rowreq_ctx *
                                                 rowreq_ctx,
                                                 struct counter64 ifHCOutUcastPkts_val);
    int             ifHCOutUcastPkts_undo_setup(ifXTable_rowreq_ctx *
                                                rowreq_ctx);
    int             ifHCOutUcastPkts_set(ifXTable_rowreq_ctx * rowreq_ctx,
                                         struct counter64 ifHCOutUcastPkts_val);
    int             ifHCOutUcastPkts_undo(ifXTable_rowreq_ctx *
                                          rowreq_ctx);

    int             ifHCOutMulticastPkts_check_value(ifXTable_rowreq_ctx *
                                                     rowreq_ctx,
                                                     struct counter64
                                                     ifHCOutMulticastPkts_val);
    int             ifHCOutMulticastPkts_undo_setup(ifXTable_rowreq_ctx *
                                                    rowreq_ctx);
    int             ifHCOutMulticastPkts_set(ifXTable_rowreq_ctx *
                                             rowreq_ctx,
                                             struct counter64 ifHCOutMulticastPkts_val);
    int             ifHCOutMulticastPkts_undo(ifXTable_rowreq_ctx *
                                              rowreq_ctx);

    int             ifHCOutBroadcastPkts_check_value(ifXTable_rowreq_ctx *
                                                     rowreq_ctx,
                                                     struct counter64
                                                     ifHCOutBroadcastPkts_val);
    int             ifHCOutBroadcastPkts_undo_setup(ifXTable_rowreq_ctx *
                                                    rowreq_ctx);
    int             ifHCOutBroadcastPkts_set(ifXTable_rowreq_ctx *
                                             rowreq_ctx,
                                             struct counter64 ifHCOutBroadcastPkts_val);
    int             ifHCOutBroadcastPkts_undo(ifXTable_rowreq_ctx *
                                              rowreq_ctx);





         * ifHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IFHCINOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCInOctets_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCInUcastPkts_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCInMulticastPkts_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCInBroadcastPkts_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutOctets_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutUcastPkts_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutMulticastPkts_get(rowreq_ctx, (struct counter64 *) 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(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ifHCOutBroadcastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
        break;

        /*

Lines 264-270 _calculate_entries(netsnmp_systemstats_entry * entry) Link Here

(-)a/agent/mibgroup/ip-mib/data_access/systemstats_common.c (-1 / +1 lines)
264	&& entry->stats.columnAvail[IPSYSTEMSTATSTABLE_HCOUTFRAGCREATES]	264	&& entry->stats.columnAvail[IPSYSTEMSTATSTABLE_HCOUTFRAGCREATES]
265	&& entry->stats.columnAvail[IPSYSTEMSTATSTABLE_HCOUTDISCARDS]) {	265	&& entry->stats.columnAvail[IPSYSTEMSTATSTABLE_HCOUTDISCARDS]) {
266		266
267	U64 tmp, tmp2, tmp3;	267	struct counter64 tmp, tmp2, tmp3;
268	tmp = entry->stats.HCOutRequests;	268	tmp = entry->stats.HCOutRequests;
269	u64Incr(&tmp, &entry->stats.HCOutForwDatagrams);	269	u64Incr(&tmp, &entry->stats.HCOutForwDatagrams);
270	u64Incr(&tmp, &entry->stats.HCOutFragCreates);	270	u64Incr(&tmp, &entry->stats.HCOutFragCreates);




 */
int
ipIfStatsHCInReceives_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                          struct counter64 *ipIfStatsHCInReceives_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInReceives_val_ptr);

 */
int
ipIfStatsHCInOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                        struct counter64 *ipIfStatsHCInOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInOctets_val_ptr);

 */
int
ipIfStatsHCInForwDatagrams_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                               struct counter64 *ipIfStatsHCInForwDatagrams_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInForwDatagrams_val_ptr);

 */
int
ipIfStatsHCInDelivers_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                          struct counter64 *ipIfStatsHCInDelivers_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInDelivers_val_ptr);

 */
int
ipIfStatsHCOutRequests_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                           struct counter64 *ipIfStatsHCOutRequests_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutRequests_val_ptr);

 */
int
ipIfStatsHCOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                                struct counter64 *ipIfStatsHCOutForwDatagrams_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutForwDatagrams_val_ptr);

 */
int
ipIfStatsHCOutTransmits_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                            struct counter64 *ipIfStatsHCOutTransmits_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutTransmits_val_ptr);

 */
int
ipIfStatsHCOutOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                         struct counter64 *ipIfStatsHCOutOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutOctets_val_ptr);

 */
int
ipIfStatsHCInMcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                           struct counter64 *ipIfStatsHCInMcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInMcastPkts_val_ptr);

 */
int
ipIfStatsHCInMcastOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                             struct counter64 *ipIfStatsHCInMcastOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInMcastOctets_val_ptr);

 */
int
ipIfStatsHCOutMcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                            struct counter64 *ipIfStatsHCOutMcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutMcastPkts_val_ptr);

 */
int
ipIfStatsHCOutMcastOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                              struct counter64 *ipIfStatsHCOutMcastOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutMcastOctets_val_ptr);

 */
int
ipIfStatsHCInBcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                           struct counter64 *ipIfStatsHCInBcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCInBcastPkts_val_ptr);

 */
int
ipIfStatsHCOutBcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
                            struct counter64 *ipIfStatsHCOutBcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipIfStatsHCOutBcastPkts_val_ptr);




                                            ipIfStatsInReceives_val_ptr);
    int             ipIfStatsHCInReceives_get(ipIfStatsTable_rowreq_ctx *
                                              rowreq_ctx,
                                              struct counter64 *
                                              ipIfStatsHCInReceives_val_ptr);
    int             ipIfStatsInOctets_get(ipIfStatsTable_rowreq_ctx *
                                          rowreq_ctx,

                                          ipIfStatsInOctets_val_ptr);
    int             ipIfStatsHCInOctets_get(ipIfStatsTable_rowreq_ctx *
                                            rowreq_ctx,
                                            struct counter64 *
                                            ipIfStatsHCInOctets_val_ptr);
    int             ipIfStatsInHdrErrors_get(ipIfStatsTable_rowreq_ctx *
                                             rowreq_ctx,

    int            
        ipIfStatsHCInForwDatagrams_get(ipIfStatsTable_rowreq_ctx *
                                       rowreq_ctx,
                                       struct counter64 *
                                       ipIfStatsHCInForwDatagrams_val_ptr);
    int             ipIfStatsReasmReqds_get(ipIfStatsTable_rowreq_ctx *
                                            rowreq_ctx,

                                            ipIfStatsInDelivers_val_ptr);
    int             ipIfStatsHCInDelivers_get(ipIfStatsTable_rowreq_ctx *
                                              rowreq_ctx,
                                              struct counter64 *
                                              ipIfStatsHCInDelivers_val_ptr);
    int             ipIfStatsOutRequests_get(ipIfStatsTable_rowreq_ctx *
                                             rowreq_ctx,

                                             ipIfStatsOutRequests_val_ptr);
    int             ipIfStatsHCOutRequests_get(ipIfStatsTable_rowreq_ctx *
                                               rowreq_ctx,
                                               struct counter64 *
                                               ipIfStatsHCOutRequests_val_ptr);
    int             ipIfStatsOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx
                                                  * rowreq_ctx,

    int            
        ipIfStatsHCOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx *
                                        rowreq_ctx,
                                        struct counter64 *
                                        ipIfStatsHCOutForwDatagrams_val_ptr);
    int             ipIfStatsOutDiscards_get(ipIfStatsTable_rowreq_ctx *
                                             rowreq_ctx,

                                              ipIfStatsOutTransmits_val_ptr);
    int             ipIfStatsHCOutTransmits_get(ipIfStatsTable_rowreq_ctx *
                                                rowreq_ctx,
                                                struct counter64 *
                                                ipIfStatsHCOutTransmits_val_ptr);
    int             ipIfStatsOutOctets_get(ipIfStatsTable_rowreq_ctx *
                                           rowreq_ctx,

                                           ipIfStatsOutOctets_val_ptr);
    int             ipIfStatsHCOutOctets_get(ipIfStatsTable_rowreq_ctx *
                                             rowreq_ctx,
                                             struct counter64 *
                                             ipIfStatsHCOutOctets_val_ptr);
    int             ipIfStatsInMcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                             rowreq_ctx,

                                             ipIfStatsInMcastPkts_val_ptr);
    int             ipIfStatsHCInMcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                               rowreq_ctx,
                                               struct counter64 *
                                               ipIfStatsHCInMcastPkts_val_ptr);
    int             ipIfStatsInMcastOctets_get(ipIfStatsTable_rowreq_ctx *
                                               rowreq_ctx,

                                               ipIfStatsInMcastOctets_val_ptr);
    int             ipIfStatsHCInMcastOctets_get(ipIfStatsTable_rowreq_ctx
                                                 * rowreq_ctx,
                                                 struct counter64 *
                                                 ipIfStatsHCInMcastOctets_val_ptr);
    int             ipIfStatsOutMcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                              rowreq_ctx,

                                              ipIfStatsOutMcastPkts_val_ptr);
    int             ipIfStatsHCOutMcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                                rowreq_ctx,
                                                struct counter64 *
                                                ipIfStatsHCOutMcastPkts_val_ptr);
    int             ipIfStatsOutMcastOctets_get(ipIfStatsTable_rowreq_ctx *
                                                rowreq_ctx,

                                                ipIfStatsOutMcastOctets_val_ptr);
    int             ipIfStatsHCOutMcastOctets_get(ipIfStatsTable_rowreq_ctx
                                                  * rowreq_ctx,
                                                  struct counter64 *
                                                  ipIfStatsHCOutMcastOctets_val_ptr);
    int             ipIfStatsInBcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                             rowreq_ctx,

                                             ipIfStatsInBcastPkts_val_ptr);
    int             ipIfStatsHCInBcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                               rowreq_ctx,
                                               struct counter64 *
                                               ipIfStatsHCInBcastPkts_val_ptr);
    int             ipIfStatsOutBcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                              rowreq_ctx,

                                              ipIfStatsOutBcastPkts_val_ptr);
    int             ipIfStatsHCOutBcastPkts_get(ipIfStatsTable_rowreq_ctx *
                                                rowreq_ctx,
                                                struct counter64 *
                                                ipIfStatsHCOutBcastPkts_val_ptr);
    int            
        ipIfStatsDiscontinuityTime_get(ipIfStatsTable_rowreq_ctx *




         * ipIfStatsHCInReceives(4)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCINRECEIVES:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCInReceives_get(rowreq_ctx,
                                       (struct counter64 *) var->val.string);
        break;

        /*

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

        /*

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

        /*

         * ipIfStatsHCInDelivers(19)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCINDELIVERS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCInDelivers_get(rowreq_ctx,
                                       (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutRequests(21)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTREQUESTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutRequests_get(rowreq_ctx,
                                        (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutForwDatagrams(24)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTFORWDATAGRAMS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutForwDatagrams_get(rowreq_ctx,
                                             (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutTransmits(31)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTTRANSMITS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutTransmits_get(rowreq_ctx,
                                         (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutOctets(33)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutOctets_get(rowreq_ctx, (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCInMcastPkts(35)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCINMCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCInMcastPkts_get(rowreq_ctx,
                                        (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCInMcastOctets(37)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCINMCASTOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCInMcastOctets_get(rowreq_ctx,
                                          (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutMcastPkts(39)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTMCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutMcastPkts_get(rowreq_ctx,
                                         (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutMcastOctets(41)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTMCASTOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutMcastOctets_get(rowreq_ctx,
                                           (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCInBcastPkts(43)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCINBCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCInBcastPkts_get(rowreq_ctx,
                                        (struct counter64 *) var->val.string);
        break;

        /*

         * ipIfStatsHCOutBcastPkts(45)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPIFSTATSHCOUTBCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipIfStatsHCOutBcastPkts_get(rowreq_ctx,
                                         (struct counter64 *) var->val.string);
        break;

        /*




 */
int
ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                              struct counter64 *ipSystemStatsHCInReceives_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCInReceives_val_ptr);

 */
int
ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                            struct counter64 *ipSystemStatsHCInOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCInOctets_val_ptr);

int
ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
                                   rowreq_ctx,
                                   struct counter64 *
                                   ipSystemStatsHCInForwDatagrams_val_ptr)
{
   /** we should have a non-NULL pointer */

 */
int
ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                              struct counter64 *ipSystemStatsHCInDelivers_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCInDelivers_val_ptr);

 */
int
ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                               struct counter64 *ipSystemStatsHCOutRequests_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCOutRequests_val_ptr);

int
ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    struct counter64 *
                                    ipSystemStatsHCOutForwDatagrams_val_ptr)
{
   /** we should have a non-NULL pointer */

 */
int
ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                                struct counter64 *ipSystemStatsHCOutTransmits_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCOutTransmits_val_ptr);

 */
int
ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                             struct counter64 *ipSystemStatsHCOutOctets_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCOutOctets_val_ptr);

 */
int
ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                               struct counter64 *ipSystemStatsHCInMcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCInMcastPkts_val_ptr);

int
ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
                                 rowreq_ctx,
                                 struct counter64 *
                                 ipSystemStatsHCInMcastOctets_val_ptr)
{
   /** we should have a non-NULL pointer */

 */
int
ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                                struct counter64 *ipSystemStatsHCOutMcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCOutMcastPkts_val_ptr);

int
ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
                                  rowreq_ctx,
                                  struct counter64 *
                                  ipSystemStatsHCOutMcastOctets_val_ptr)
{
   /** we should have a non-NULL pointer */

 */
int
ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                               struct counter64 *ipSystemStatsHCInBcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCInBcastPkts_val_ptr);

 */
int
ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
                                struct counter64 *ipSystemStatsHCOutBcastPkts_val_ptr)
{
   /** we should have a non-NULL pointer */
    netsnmp_assert(NULL != ipSystemStatsHCOutBcastPkts_val_ptr);




     *********************************************************************
     * function prototypes
     */
    int ipSystemStatsTable_pre_request(ipSystemStatsTable_registration *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsTable_pre_request(ipSystemStatsTable_registration *
                                       user_context);
    int ipSystemStatsTable_post_request(ipSystemStatsTable_registration *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsTable_post_request(ipSystemStatsTable_registration *
                                        user_context, int rc);

    int ipSystemStatsTable_rowreq_ctx_init(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsTable_rowreq_ctx_init(ipSystemStatsTable_rowreq_ctx *
                                           rowreq_ctx,
                                           void *user_init_ctx);
    void
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsTable_rowreq_ctx_cleanup(ipSystemStatsTable_rowreq_ctx
                                              * rowreq_ctx);

    ipSystemStatsTable_data *ipSystemStatsTable_allocate_data(void);
    void            ipSystemStatsTable_release_data(ipSystemStatsTable_data
                                                    * data);
    ipSystemStatsTable_rowreq_ctx

         
         
         
         
         
         
        ipSystemStatsTable_rowreq_ctx
        * ipSystemStatsTable_row_find_by_mib_index
        (ipSystemStatsTable_mib_index * mib_idx);


     * indexes
     */

    int ipSystemStatsInReceives_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInReceives_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsInReceives_val_ptr);
    int ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      struct counter64 *
                                      ipSystemStatsHCInReceives_val_ptr);
    int             ipSystemStatsInOctets_get(ipSystemStatsTable_rowreq_ctx
                                              * rowreq_ctx,
                                              u_long *
                                              ipSystemStatsInOctets_val_ptr);
    int ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    struct counter64 *ipSystemStatsHCInOctets_val_ptr);
    int ipSystemStatsInHdrErrors_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInHdrErrors_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsInHdrErrors_val_ptr);
    int ipSystemStatsInNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsInNoRoutes_val_ptr);
    int ipSystemStatsInAddrErrors_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInAddrErrors_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long *
                                      ipSystemStatsInAddrErrors_val_ptr);
    int ipSystemStatsInUnknownProtos_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInUnknownProtos_get(ipSystemStatsTable_rowreq_ctx *
                                         rowreq_ctx,
                                         u_long *
                                         ipSystemStatsInUnknownProtos_val_ptr);
    int ipSystemStatsInTruncatedPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInTruncatedPkts_get(ipSystemStatsTable_rowreq_ctx *
                                         rowreq_ctx,
                                         u_long *
                                         ipSystemStatsInTruncatedPkts_val_ptr);
    int ipSystemStatsInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
                                         rowreq_ctx,
                                         u_long *
                                         ipSystemStatsInForwDatagrams_val_ptr);
    int ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
                                           rowreq_ctx,
                                           struct counter64 *
                                           ipSystemStatsHCInForwDatagrams_val_ptr);
    int ipSystemStatsReasmReqds_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsReasmReqds_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsReasmReqds_val_ptr);

                                              * rowreq_ctx,
                                              u_long *
                                              ipSystemStatsReasmOKs_val_ptr);
    int ipSystemStatsReasmFails_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsReasmFails_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsReasmFails_val_ptr);
    int ipSystemStatsInDiscards_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInDiscards_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsInDiscards_val_ptr);
    int ipSystemStatsInDelivers_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInDelivers_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsInDelivers_val_ptr);
    int ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      struct counter64 *
                                      ipSystemStatsHCInDelivers_val_ptr);
    int ipSystemStatsOutRequests_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutRequests_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsOutRequests_val_ptr);
    int ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx *
                                       rowreq_ctx,
                                       struct counter64 *
                                       ipSystemStatsHCOutRequests_val_ptr);
    int ipSystemStatsOutNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsOutNoRoutes_val_ptr);
    int ipSystemStatsOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
                                          rowreq_ctx,
                                          u_long *
                                          ipSystemStatsOutForwDatagrams_val_ptr);
    int ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
                                            rowreq_ctx,
                                            struct counter64 *
                                            ipSystemStatsHCOutForwDatagrams_val_ptr);
    int ipSystemStatsOutDiscards_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutDiscards_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsOutDiscards_val_ptr);
    int ipSystemStatsOutFragReqds_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutFragReqds_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long *
                                      ipSystemStatsOutFragReqds_val_ptr);
    int ipSystemStatsOutFragOKs_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutFragOKs_get(ipSystemStatsTable_rowreq_ctx *
                                    rowreq_ctx,
                                    u_long *
                                    ipSystemStatsOutFragOKs_val_ptr);
    int ipSystemStatsOutFragFails_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutFragFails_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long *
                                      ipSystemStatsOutFragFails_val_ptr);
    int ipSystemStatsOutFragCreates_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutFragCreates_get(ipSystemStatsTable_rowreq_ctx *
                                        rowreq_ctx,
                                        u_long *
                                        ipSystemStatsOutFragCreates_val_ptr);
    int ipSystemStatsOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long *
                                      ipSystemStatsOutTransmits_val_ptr);
    int ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
                                        rowreq_ctx,
                                        struct counter64 *
                                        ipSystemStatsHCOutTransmits_val_ptr);
    int ipSystemStatsOutOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutOctets_get(ipSystemStatsTable_rowreq_ctx *
                                   rowreq_ctx,
                                   u_long *
                                   ipSystemStatsOutOctets_val_ptr);
    int ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     struct counter64 *
                                     ipSystemStatsHCOutOctets_val_ptr);
    int ipSystemStatsInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsInMcastPkts_val_ptr);
    int ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                       rowreq_ctx,
                                       struct counter64 *
                                       ipSystemStatsHCInMcastPkts_val_ptr);
    int ipSystemStatsInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
                                       rowreq_ctx,
                                       u_long *
                                       ipSystemStatsInMcastOctets_val_ptr);
    int ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
                                         rowreq_ctx,
                                         struct counter64 *
                                         ipSystemStatsHCInMcastOctets_val_ptr);
    int ipSystemStatsOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long *
                                      ipSystemStatsOutMcastPkts_val_ptr);
    int ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                        rowreq_ctx,
                                        struct counter64 *
                                        ipSystemStatsHCOutMcastPkts_val_ptr);
    int ipSystemStatsOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
                                        rowreq_ctx,
                                        u_long *
                                        ipSystemStatsOutMcastOctets_val_ptr);
    int ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
                                          rowreq_ctx,
                                          struct counter64 *
                                          ipSystemStatsHCOutMcastOctets_val_ptr);
    int ipSystemStatsInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsInBcastPkts_val_ptr);
    int ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                       rowreq_ctx,
                                       struct counter64 *
                                       ipSystemStatsHCInBcastPkts_val_ptr);
    int ipSystemStatsOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                      rowreq_ctx,
                                      u_long *
                                      ipSystemStatsOutBcastPkts_val_ptr);
    int ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
                                        rowreq_ctx,
                                        struct counter64 *
                                        ipSystemStatsHCOutBcastPkts_val_ptr);
    int ipSystemStatsDiscontinuityTime_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsDiscontinuityTime_get(ipSystemStatsTable_rowreq_ctx *
                                           rowreq_ctx,
                                           u_long *
                                           ipSystemStatsDiscontinuityTime_val_ptr);
    int ipSystemStatsRefreshRate_get(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsRefreshRate_get(ipSystemStatsTable_rowreq_ctx *
                                     rowreq_ctx,
                                     u_long *
                                     ipSystemStatsRefreshRate_val_ptr);
    int ipSystemStatsTable_indexes_set_tbl_idx(ipSystemStatsTable_mib_index

    int
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsTable_indexes_set_tbl_idx(ipSystemStatsTable_mib_index
                                               * tbl_idx,
                                               u_long
                                               ipSystemStatsIPVersion_val);
    int ipSystemStatsTable_indexes_set(ipSystemStatsTable_rowreq_ctx *
     
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        ipSystemStatsTable_indexes_set(ipSystemStatsTable_rowreq_ctx *
                                       rowreq_ctx,
                                       u_long ipSystemStatsIPVersion_val);



    /*
     *********************************************************************
     * SET function declarations




         * ipSystemStatsHCInReceives(4)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCINRECEIVES:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCInReceives_get(rowreq_ctx,
                                           (struct counter64 *) var->val.string);
        break;

        /*

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

        /*

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

        /*

         * ipSystemStatsHCInDelivers(19)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCINDELIVERS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCInDelivers_get(rowreq_ctx,
                                           (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutRequests(21)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTREQUESTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutRequests_get(rowreq_ctx,
                                            (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutForwDatagrams(24)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTFORWDATAGRAMS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutForwDatagrams_get(rowreq_ctx,
                                                 (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutTransmits(31)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTTRANSMITS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutTransmits_get(rowreq_ctx,
                                             (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutOctets(33)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutOctets_get(rowreq_ctx,
                                          (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCInMcastPkts(35)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCINMCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCInMcastPkts_get(rowreq_ctx,
                                            (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCInMcastOctets(37)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCINMCASTOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCInMcastOctets_get(rowreq_ctx,
                                              (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutMcastPkts(39)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTMCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutMcastPkts_get(rowreq_ctx,
                                             (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutMcastOctets(41)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTMCASTOCTETS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutMcastOctets_get(rowreq_ctx,
                                               (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCInBcastPkts(43)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCINBCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCInBcastPkts_get(rowreq_ctx,
                                            (struct counter64 *) var->val.string);
        break;

        /*

         * ipSystemStatsHCOutBcastPkts(45)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h 
         */
    case COLUMN_IPSYSTEMSTATSHCOUTBCASTPKTS:
        var->val_len = sizeof(struct counter64);
        var->type = ASN_COUNTER64;
        rc = ipSystemStatsHCOutBcastPkts_get(rowreq_ctx,
                                             (struct counter64 *) var->val.string);
        break;

        /*




    * other columns, when underlying OS does not provide them.
    * Always fill at least 32 bits, the table is periodically polled -> 32 bit
    * overflow shall be detected and 64 bit value should be computed automatically. */
   struct counter64 HCInReceives;
   struct counter64 HCInOctets;
   u_long          InHdrErrors;
   struct counter64 HCInNoRoutes; 
   u_long          InAddrErrors;
   u_long          InUnknownProtos;
   u_long          InTruncatedPkts;
   
   /* optional, can be computed from HCInNoRoutes and HCOutForwDatagrams */
   struct counter64 HCInForwDatagrams; 
   
   u_long          ReasmReqds;
   u_long          ReasmOKs;
   u_long          ReasmFails;
   u_long          InDiscards;
   struct counter64 HCInDelivers;
   struct counter64 HCOutRequests;
   struct counter64 HCOutNoRoutes;
   struct counter64 HCOutForwDatagrams;
   struct counter64 HCOutDiscards;
   
   /* optional, can be computed from HCOutFragOKs + HCOutFragFails*/
   struct counter64 HCOutFragReqds;
   struct counter64 HCOutFragOKs;
   struct counter64 HCOutFragFails;
   struct counter64 HCOutFragCreates;
   
   /* optional, can be computed from 
    * HCOutRequests +HCOutForwDatagrams + HCOutFragCreates
    * - HCOutFragReqds - HCOutNoRoutes  - HCOutDiscards */
   struct counter64 HCOutTransmits;
   
   struct counter64 HCOutOctets;
   struct counter64 HCInMcastPkts;
   struct counter64 HCInMcastOctets;
   struct counter64 HCOutMcastPkts;
   struct counter64 HCOutMcastOctets;
   struct counter64 HCInBcastPkts;
   struct counter64 HCOutBcastPkts;

   /* Array of available columns.*/
   int             columnAvail[IPSYSTEMSTATSTABLE_LAST+1];




extern          "C" {
#endif

    typedef struct counter64 U64;

#define I64CHARSZ 21

    void            divBy10(struct counter64, struct counter64 *, unsigned int *);
    void            multBy10(struct counter64, struct counter64 *);
    void            incrByU16(struct counter64 *, unsigned int);
    void            incrByU32(struct counter64 *, unsigned int);
    NETSNMP_IMPORT
    void            zeroU64(struct counter64 *);
    int             isZeroU64(const struct counter64 *);
    NETSNMP_IMPORT
    void            printU64(char *, const struct counter64 *);
    NETSNMP_IMPORT
    void            printI64(char *, const struct counter64 *);
    int             read64(struct counter64 *, const char *);
    NETSNMP_IMPORT
    void            u64Subtract(const struct counter64 *pu64one, const struct counter64 *pu64two,
                                struct counter64 *pu64out);
    void            u64Incr(struct counter64 *pu64out, const struct counter64 *pu64one);
    void            u64UpdateCounter(struct counter64 *pu64out, const struct counter64 *pu64one,
                                     const struct counter64 *pu64two);
    void            u64Copy(struct counter64 *pu64one, const struct counter64 *pu64two);

    int             netsnmp_c64_check_for_32bit_wrap(struct counter64 *old_val, struct counter64 *new_val,
                                                     int adjust);
    NETSNMP_IMPORT
    int             netsnmp_c64_check32_and_update(struct counter64 *prev_val,




 * @param[out] puR   Remainder.
 */
void
divBy10(struct counter64 u64, struct counter64 *pu64Q, unsigned int *puR)
{
    unsigned long   ulT;
    unsigned long   ulQ;

 * @param[out] pu64P Product.
 */
void
multBy10(struct counter64 u64, struct counter64 *pu64P)
{
    unsigned long   ulT;
    unsigned long   ulP;

 *
 */
void
incrByU16(struct counter64 *pu64, unsigned int u16)
{
    incrByU32(pu64, u16);
}

 *
 */
void
incrByU32(struct counter64 *pu64, unsigned int u32)
{
    uint32_t tmp;


 * @param[out] pu64out pu64one - pu64two.
 */
void
u64Subtract(const struct counter64 *pu64one, const struct counter64 *pu64two, struct counter64 *pu64out)
{
    int carry;


 * @param[in,out] pu64out pu64out += pu64one.
 */
void
u64Incr(struct counter64 *pu64out, const struct counter64 *pu64one)
{
    pu64out->high = (uint32_t)(pu64out->high + pu64one->high);
    incrByU32(pu64out, pu64one->low);

 * @param[out] pu64out pu64out += (pu64one - pu64two)
 */
void
u64UpdateCounter(struct counter64 *pu64out, const struct counter64 *pu64one, const struct counter64 *pu64two)
{
    struct counter64 tmp;

    u64Subtract(pu64one, pu64two, &tmp);
    u64Incr(pu64out, &tmp);

 * @param[out] pu64one Where to store the copy - *pu64one = *pu64two.
 */
void
u64Copy(struct counter64 *pu64one, const struct counter64 *pu64two)
{
    *pu64one = *pu64two;
}

 * @param[in] pu64 Number to be zeroed.
 */
void
zeroU64(struct counter64 *pu64)
{
    pu64->low = 0;
    pu64->high = 0;

 * @param[in] pu64 Number to be checked.
 */
int
isZeroU64(const struct counter64 *pu64)
{
    return pu64->low == 0 && pu64->high == 0;
}

/** Convert an unsigned 64-bit number to ASCII. */
void
printU64(char *buf, /* char [I64CHARSZ+1]; */
         const struct counter64 *pu64)
{
    struct counter64 u64a;
    struct counter64 u64b;

    char            aRes[I64CHARSZ + 1];
    unsigned int    u;

/** Convert a signed 64-bit number to ASCII. */
void
printI64(char *buf, /* char [I64CHARSZ+1]; */
         const struct counter64 *pu64)
{
    struct counter64 u64a;

    if (pu64->high & 0x80000000) {
        u64a.high = (uint32_t) ~pu64->high;

    }
}

/** Convert a signed 64-bit integer from ASCII to struct counter64. */
int
read64(struct counter64 *i64, const char *str)
{
    struct counter64 i64p;
    unsigned int    u;
    int             sign = 0;
    int             ok = 0;

Lines 2279-2288 read_config_read_memory(int type, char *readfrom, Link Here

(-)a/snmplib/read_config.c (-3 / +3 lines)
2279	return readfrom;	2279	return readfrom;
2280		2280
2281	case ASN_COUNTER64:	2281	case ASN_COUNTER64:
2282	if (*len < sizeof(U64))	2282	if (*len < sizeof(struct counter64))
2283	return NULL;	2283	return NULL;
2284	*len = sizeof(U64);	2284	*len = sizeof(struct counter64);
2285	read64((U64 *) dataptr, readfrom);	2285	read64((struct counter64 *) dataptr, readfrom);
2286	readfrom = skip_token(readfrom);	2286	readfrom = skip_token(readfrom);
2287	return readfrom;	2287	return readfrom;
2288	}	2288	}




/* HEADER Testing 64-bit integer operations (struct counter64). */

int i, j;
char buf[22];

};

for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
    struct counter64 a, b;
    a.low = (uint32_t)intval[i];
    a.high = (uint32_t)(intval[i] >> 32);
    printI64(buf, &a);


for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
    for (j = i; j < sizeof(intval)/sizeof(intval[0]); ++j) {
        struct counter64 a, b;
        uint64_t d;
        a.low = (uint32_t)intval[i];
        a.high = (uint32_t)(intval[i] >> 32);

        
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
    for (j = i; j < sizeof(intval)/sizeof(intval[0]); ++j) {
        struct counter64 a, b, c;
        uint64_t d;
        a.low = (uint32_t)intval[i];
        a.high = (uint32_t)(intval[i] >> 32);

}
        
{
    struct counter64 old_val, new_val;
    old_val.low = 7;
    old_val.high = 0;
    new_val = old_val;
- 

Return to bug 582368

Lines 143-170 config_require(if-mib/ifXTable/ifXTable_data_access) Link Here

(-)a/agent/mibgroup/if-mib/ifXTable/ifXTable.h (-24 / +24 lines)
143	u_long *	143	u_long *
144	ifOutBroadcastPkts_val_ptr);	144	ifOutBroadcastPkts_val_ptr);
145	int ifHCInOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,	145	int ifHCInOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
146	U64 * ifHCInOctets_val_ptr);	146	struct counter64 *ifHCInOctets_val_ptr);
147	int ifHCInUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	147	int ifHCInUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
148	U64 * ifHCInUcastPkts_val_ptr);	148	struct counter64 *ifHCInUcastPkts_val_ptr);
149	int ifHCInMulticastPkts_get(ifXTable_rowreq_ctx *	149	int ifHCInMulticastPkts_get(ifXTable_rowreq_ctx *
150	rowreq_ctx,	150	rowreq_ctx,
151	U64 *	151	struct counter64 *
152	ifHCInMulticastPkts_val_ptr);	152	ifHCInMulticastPkts_val_ptr);
153	int ifHCInBroadcastPkts_get(ifXTable_rowreq_ctx *	153	int ifHCInBroadcastPkts_get(ifXTable_rowreq_ctx *
154	rowreq_ctx,	154	rowreq_ctx,
155	U64 *	155	struct counter64 *
156	ifHCInBroadcastPkts_val_ptr);	156	ifHCInBroadcastPkts_val_ptr);
157	int ifHCOutOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,	157	int ifHCOutOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
158	U64 * ifHCOutOctets_val_ptr);	158	struct counter64 *ifHCOutOctets_val_ptr);
159	int ifHCOutUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	159	int ifHCOutUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
160	U64 * ifHCOutUcastPkts_val_ptr);	160	struct counter64 *ifHCOutUcastPkts_val_ptr);
161	int ifHCOutMulticastPkts_get(ifXTable_rowreq_ctx *	161	int ifHCOutMulticastPkts_get(ifXTable_rowreq_ctx *
162	rowreq_ctx,	162	rowreq_ctx,
163	U64 *	163	struct counter64 *
164	ifHCOutMulticastPkts_val_ptr);	164	ifHCOutMulticastPkts_val_ptr);
165	int ifHCOutBroadcastPkts_get(ifXTable_rowreq_ctx *	165	int ifHCOutBroadcastPkts_get(ifXTable_rowreq_ctx *
166	rowreq_ctx,	166	rowreq_ctx,
167	U64 *	167	struct counter64 *
168	ifHCOutBroadcastPkts_val_ptr);	168	ifHCOutBroadcastPkts_val_ptr);
169	int ifLinkUpDownTrapEnable_get(ifXTable_rowreq_ctx *	169	int ifLinkUpDownTrapEnable_get(ifXTable_rowreq_ctx *
170	rowreq_ctx,	170	rowreq_ctx,
Lines 284-369 config_require(if-mib/ifXTable/ifXTable_data_access) Link Here
284		284
285	int ifHCInOctets_check_value(ifXTable_rowreq_ctx *	285	int ifHCInOctets_check_value(ifXTable_rowreq_ctx *
286	rowreq_ctx,	286	rowreq_ctx,
287	U64 ifHCInOctets_val);	287	struct counter64 ifHCInOctets_val);
288	int ifHCInOctets_undo_setup(ifXTable_rowreq_ctx *	288	int ifHCInOctets_undo_setup(ifXTable_rowreq_ctx *
289	rowreq_ctx);	289	rowreq_ctx);
290	int ifHCInOctets_set(ifXTable_rowreq_ctx * rowreq_ctx,	290	int ifHCInOctets_set(ifXTable_rowreq_ctx * rowreq_ctx,
291	U64 ifHCInOctets_val);	291	struct counter64 ifHCInOctets_val);
292	int ifHCInOctets_undo(ifXTable_rowreq_ctx * rowreq_ctx);	292	int ifHCInOctets_undo(ifXTable_rowreq_ctx * rowreq_ctx);
293		293
294	int ifHCInUcastPkts_check_value(ifXTable_rowreq_ctx *	294	int ifHCInUcastPkts_check_value(ifXTable_rowreq_ctx *
295	rowreq_ctx,	295	rowreq_ctx,
296	U64 ifHCInUcastPkts_val);	296	struct counter64 ifHCInUcastPkts_val);
297	int ifHCInUcastPkts_undo_setup(ifXTable_rowreq_ctx *	297	int ifHCInUcastPkts_undo_setup(ifXTable_rowreq_ctx *
298	rowreq_ctx);	298	rowreq_ctx);
299	int ifHCInUcastPkts_set(ifXTable_rowreq_ctx * rowreq_ctx,	299	int ifHCInUcastPkts_set(ifXTable_rowreq_ctx * rowreq_ctx,
300	U64 ifHCInUcastPkts_val);	300	struct counter64 ifHCInUcastPkts_val);
301	int ifHCInUcastPkts_undo(ifXTable_rowreq_ctx * rowreq_ctx);	301	int ifHCInUcastPkts_undo(ifXTable_rowreq_ctx * rowreq_ctx);
302		302
303	int ifHCInMulticastPkts_check_value(ifXTable_rowreq_ctx *	303	int ifHCInMulticastPkts_check_value(ifXTable_rowreq_ctx *
304	rowreq_ctx,	304	rowreq_ctx,
305	U64	305	struct counter64
306	ifHCInMulticastPkts_val);	306	ifHCInMulticastPkts_val);
307	int ifHCInMulticastPkts_undo_setup(ifXTable_rowreq_ctx *	307	int ifHCInMulticastPkts_undo_setup(ifXTable_rowreq_ctx *
308	rowreq_ctx);	308	rowreq_ctx);
309	int ifHCInMulticastPkts_set(ifXTable_rowreq_ctx *	309	int ifHCInMulticastPkts_set(ifXTable_rowreq_ctx *
310	rowreq_ctx,	310	rowreq_ctx,
311	U64 ifHCInMulticastPkts_val);	311	struct counter64 ifHCInMulticastPkts_val);
312	int ifHCInMulticastPkts_undo(ifXTable_rowreq_ctx *	312	int ifHCInMulticastPkts_undo(ifXTable_rowreq_ctx *
313	rowreq_ctx);	313	rowreq_ctx);
314		314
315	int ifHCInBroadcastPkts_check_value(ifXTable_rowreq_ctx *	315	int ifHCInBroadcastPkts_check_value(ifXTable_rowreq_ctx *
316	rowreq_ctx,	316	rowreq_ctx,
317	U64	317	struct counter64
318	ifHCInBroadcastPkts_val);	318	ifHCInBroadcastPkts_val);
319	int ifHCInBroadcastPkts_undo_setup(ifXTable_rowreq_ctx *	319	int ifHCInBroadcastPkts_undo_setup(ifXTable_rowreq_ctx *
320	rowreq_ctx);	320	rowreq_ctx);
321	int ifHCInBroadcastPkts_set(ifXTable_rowreq_ctx *	321	int ifHCInBroadcastPkts_set(ifXTable_rowreq_ctx *
322	rowreq_ctx,	322	rowreq_ctx,
323	U64 ifHCInBroadcastPkts_val);	323	struct counter64 ifHCInBroadcastPkts_val);
324	int ifHCInBroadcastPkts_undo(ifXTable_rowreq_ctx *	324	int ifHCInBroadcastPkts_undo(ifXTable_rowreq_ctx *
325	rowreq_ctx);	325	rowreq_ctx);
326		326
327	int ifHCOutOctets_check_value(ifXTable_rowreq_ctx *	327	int ifHCOutOctets_check_value(ifXTable_rowreq_ctx *
328	rowreq_ctx,	328	rowreq_ctx,
329	U64 ifHCOutOctets_val);	329	struct counter64 ifHCOutOctets_val);
330	int ifHCOutOctets_undo_setup(ifXTable_rowreq_ctx *	330	int ifHCOutOctets_undo_setup(ifXTable_rowreq_ctx *
331	rowreq_ctx);	331	rowreq_ctx);
332	int ifHCOutOctets_set(ifXTable_rowreq_ctx * rowreq_ctx,	332	int ifHCOutOctets_set(ifXTable_rowreq_ctx * rowreq_ctx,
333	U64 ifHCOutOctets_val);	333	struct counter64 ifHCOutOctets_val);
334	int ifHCOutOctets_undo(ifXTable_rowreq_ctx * rowreq_ctx);	334	int ifHCOutOctets_undo(ifXTable_rowreq_ctx * rowreq_ctx);
335		335
336	int ifHCOutUcastPkts_check_value(ifXTable_rowreq_ctx *	336	int ifHCOutUcastPkts_check_value(ifXTable_rowreq_ctx *
337	rowreq_ctx,	337	rowreq_ctx,
338	U64 ifHCOutUcastPkts_val);	338	struct counter64 ifHCOutUcastPkts_val);
339	int ifHCOutUcastPkts_undo_setup(ifXTable_rowreq_ctx *	339	int ifHCOutUcastPkts_undo_setup(ifXTable_rowreq_ctx *
340	rowreq_ctx);	340	rowreq_ctx);
341	int ifHCOutUcastPkts_set(ifXTable_rowreq_ctx * rowreq_ctx,	341	int ifHCOutUcastPkts_set(ifXTable_rowreq_ctx * rowreq_ctx,
342	U64 ifHCOutUcastPkts_val);	342	struct counter64 ifHCOutUcastPkts_val);
343	int ifHCOutUcastPkts_undo(ifXTable_rowreq_ctx *	343	int ifHCOutUcastPkts_undo(ifXTable_rowreq_ctx *
344	rowreq_ctx);	344	rowreq_ctx);
345		345
346	int ifHCOutMulticastPkts_check_value(ifXTable_rowreq_ctx *	346	int ifHCOutMulticastPkts_check_value(ifXTable_rowreq_ctx *
347	rowreq_ctx,	347	rowreq_ctx,
348	U64	348	struct counter64
349	ifHCOutMulticastPkts_val);	349	ifHCOutMulticastPkts_val);
350	int ifHCOutMulticastPkts_undo_setup(ifXTable_rowreq_ctx *	350	int ifHCOutMulticastPkts_undo_setup(ifXTable_rowreq_ctx *
351	rowreq_ctx);	351	rowreq_ctx);
352	int ifHCOutMulticastPkts_set(ifXTable_rowreq_ctx *	352	int ifHCOutMulticastPkts_set(ifXTable_rowreq_ctx *
353	rowreq_ctx,	353	rowreq_ctx,
354	U64 ifHCOutMulticastPkts_val);	354	struct counter64 ifHCOutMulticastPkts_val);
355	int ifHCOutMulticastPkts_undo(ifXTable_rowreq_ctx *	355	int ifHCOutMulticastPkts_undo(ifXTable_rowreq_ctx *
356	rowreq_ctx);	356	rowreq_ctx);
357		357
358	int ifHCOutBroadcastPkts_check_value(ifXTable_rowreq_ctx *	358	int ifHCOutBroadcastPkts_check_value(ifXTable_rowreq_ctx *
359	rowreq_ctx,	359	rowreq_ctx,
360	U64	360	struct counter64
361	ifHCOutBroadcastPkts_val);	361	ifHCOutBroadcastPkts_val);
362	int ifHCOutBroadcastPkts_undo_setup(ifXTable_rowreq_ctx *	362	int ifHCOutBroadcastPkts_undo_setup(ifXTable_rowreq_ctx *
363	rowreq_ctx);	363	rowreq_ctx);
364	int ifHCOutBroadcastPkts_set(ifXTable_rowreq_ctx *	364	int ifHCOutBroadcastPkts_set(ifXTable_rowreq_ctx *
365	rowreq_ctx,	365	rowreq_ctx,
366	U64 ifHCOutBroadcastPkts_val);	366	struct counter64 ifHCOutBroadcastPkts_val);
367	int ifHCOutBroadcastPkts_undo(ifXTable_rowreq_ctx *	367	int ifHCOutBroadcastPkts_undo(ifXTable_rowreq_ctx *
368	rowreq_ctx);	368	rowreq_ctx);
369		369

Lines 729-800 _ifXTable_get_column(ifXTable_rowreq_ctx * rowreq_ctx, Link Here

(-)a/agent/mibgroup/if-mib/ifXTable/ifXTable_interface.c (-16 / +16 lines)
729	* ifHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	729	* ifHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
730	*/	730	*/
731	case COLUMN_IFHCINOCTETS:	731	case COLUMN_IFHCINOCTETS:
732	var->val_len = sizeof(U64);	732	var->val_len = sizeof(struct counter64);
733	var->type = ASN_COUNTER64;	733	var->type = ASN_COUNTER64;
734	rc = ifHCInOctets_get(rowreq_ctx, (U64 *) var->val.string);	734	rc = ifHCInOctets_get(rowreq_ctx, (struct counter64 *) var->val.string);
735	break;	735	break;
736		736
737	/*	737	/*
738	* ifHCInUcastPkts(7)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	738	* ifHCInUcastPkts(7)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
739	*/	739	*/
740	case COLUMN_IFHCINUCASTPKTS:	740	case COLUMN_IFHCINUCASTPKTS:
741	var->val_len = sizeof(U64);	741	var->val_len = sizeof(struct counter64);
742	var->type = ASN_COUNTER64;	742	var->type = ASN_COUNTER64;
743	rc = ifHCInUcastPkts_get(rowreq_ctx, (U64 *) var->val.string);	743	rc = ifHCInUcastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
744	break;	744	break;
745		745
746	/*	746	/*
747	* ifHCInMulticastPkts(8)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	747	* ifHCInMulticastPkts(8)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
748	*/	748	*/
749	case COLUMN_IFHCINMULTICASTPKTS:	749	case COLUMN_IFHCINMULTICASTPKTS:
750	var->val_len = sizeof(U64);	750	var->val_len = sizeof(struct counter64);
751	var->type = ASN_COUNTER64;	751	var->type = ASN_COUNTER64;
752	rc = ifHCInMulticastPkts_get(rowreq_ctx, (U64 *) var->val.string);	752	rc = ifHCInMulticastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
753	break;	753	break;
754		754
755	/*	755	/*
756	* ifHCInBroadcastPkts(9)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	756	* ifHCInBroadcastPkts(9)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
757	*/	757	*/
758	case COLUMN_IFHCINBROADCASTPKTS:	758	case COLUMN_IFHCINBROADCASTPKTS:
759	var->val_len = sizeof(U64);	759	var->val_len = sizeof(struct counter64);
760	var->type = ASN_COUNTER64;	760	var->type = ASN_COUNTER64;
761	rc = ifHCInBroadcastPkts_get(rowreq_ctx, (U64 *) var->val.string);	761	rc = ifHCInBroadcastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
762	break;	762	break;
763		763
764	/*	764	/*
765	* ifHCOutOctets(10)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	765	* ifHCOutOctets(10)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
766	*/	766	*/
767	case COLUMN_IFHCOUTOCTETS:	767	case COLUMN_IFHCOUTOCTETS:
768	var->val_len = sizeof(U64);	768	var->val_len = sizeof(struct counter64);
769	var->type = ASN_COUNTER64;	769	var->type = ASN_COUNTER64;
770	rc = ifHCOutOctets_get(rowreq_ctx, (U64 *) var->val.string);	770	rc = ifHCOutOctets_get(rowreq_ctx, (struct counter64 *) var->val.string);
771	break;	771	break;
772		772
773	/*	773	/*
774	* ifHCOutUcastPkts(11)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	774	* ifHCOutUcastPkts(11)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
775	*/	775	*/
776	case COLUMN_IFHCOUTUCASTPKTS:	776	case COLUMN_IFHCOUTUCASTPKTS:
777	var->val_len = sizeof(U64);	777	var->val_len = sizeof(struct counter64);
778	var->type = ASN_COUNTER64;	778	var->type = ASN_COUNTER64;
779	rc = ifHCOutUcastPkts_get(rowreq_ctx, (U64 *) var->val.string);	779	rc = ifHCOutUcastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
780	break;	780	break;
781		781
782	/*	782	/*
783	* ifHCOutMulticastPkts(12)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	783	* ifHCOutMulticastPkts(12)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
784	*/	784	*/
785	case COLUMN_IFHCOUTMULTICASTPKTS:	785	case COLUMN_IFHCOUTMULTICASTPKTS:
786	var->val_len = sizeof(U64);	786	var->val_len = sizeof(struct counter64);
787	var->type = ASN_COUNTER64;	787	var->type = ASN_COUNTER64;
788	rc = ifHCOutMulticastPkts_get(rowreq_ctx, (U64 *) var->val.string);	788	rc = ifHCOutMulticastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
789	break;	789	break;
790		790
791	/*	791	/*
792	* ifHCOutBroadcastPkts(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	792	* ifHCOutBroadcastPkts(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
793	*/	793	*/
794	case COLUMN_IFHCOUTBROADCASTPKTS:	794	case COLUMN_IFHCOUTBROADCASTPKTS:
795	var->val_len = sizeof(U64);	795	var->val_len = sizeof(struct counter64);
796	var->type = ASN_COUNTER64;	796	var->type = ASN_COUNTER64;
797	rc = ifHCOutBroadcastPkts_get(rowreq_ctx, (U64 *) var->val.string);	797	rc = ifHCOutBroadcastPkts_get(rowreq_ctx, (struct counter64 *) var->val.string);
798	break;	798	break;
799		799
800	/*	800	/*

Lines 722-731 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here

(-)a/agent/mibgroup/ip-mib/ipIfStatsTable/ipIfStatsTable_interface.c (-28 / +28 lines)
722	* ipIfStatsHCInReceives(4)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	722	* ipIfStatsHCInReceives(4)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
723	*/	723	*/
724	case COLUMN_IPIFSTATSHCINRECEIVES:	724	case COLUMN_IPIFSTATSHCINRECEIVES:
725	var->val_len = sizeof(U64);	725	var->val_len = sizeof(struct counter64);
726	var->type = ASN_COUNTER64;	726	var->type = ASN_COUNTER64;
727	rc = ipIfStatsHCInReceives_get(rowreq_ctx,	727	rc = ipIfStatsHCInReceives_get(rowreq_ctx,
728	(U64 *) var->val.string);	728	(struct counter64 *) var->val.string);
729	break;	729	break;
730		730
731	/*	731	/*
Lines 741-749 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
741	* ipIfStatsHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	741	* ipIfStatsHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
742	*/	742	*/
743	case COLUMN_IPIFSTATSHCINOCTETS:	743	case COLUMN_IPIFSTATSHCINOCTETS:
744	var->val_len = sizeof(U64);	744	var->val_len = sizeof(struct counter64);
745	var->type = ASN_COUNTER64;	745	var->type = ASN_COUNTER64;
746	rc = ipIfStatsHCInOctets_get(rowreq_ctx, (U64 *) var->val.string);	746	rc = ipIfStatsHCInOctets_get(rowreq_ctx, (struct counter64 *) var->val.string);
747	break;	747	break;
748		748
749	/*	749	/*
Lines 810-819 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
810	* ipIfStatsHCInForwDatagrams(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	810	* ipIfStatsHCInForwDatagrams(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
811	*/	811	*/
812	case COLUMN_IPIFSTATSHCINFORWDATAGRAMS:	812	case COLUMN_IPIFSTATSHCINFORWDATAGRAMS:
813	var->val_len = sizeof(U64);	813	var->val_len = sizeof(struct counter64);
814	var->type = ASN_COUNTER64;	814	var->type = ASN_COUNTER64;
815	rc = ipIfStatsHCInForwDatagrams_get(rowreq_ctx,	815	rc = ipIfStatsHCInForwDatagrams_get(rowreq_ctx,
816	(U64 *) var->val.string);	816	(struct counter64 *) var->val.string);
817	break;	817	break;
818		818
819	/*	819	/*
Lines 869-878 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
869	* ipIfStatsHCInDelivers(19)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	869	* ipIfStatsHCInDelivers(19)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
870	*/	870	*/
871	case COLUMN_IPIFSTATSHCINDELIVERS:	871	case COLUMN_IPIFSTATSHCINDELIVERS:
872	var->val_len = sizeof(U64);	872	var->val_len = sizeof(struct counter64);
873	var->type = ASN_COUNTER64;	873	var->type = ASN_COUNTER64;
874	rc = ipIfStatsHCInDelivers_get(rowreq_ctx,	874	rc = ipIfStatsHCInDelivers_get(rowreq_ctx,
875	(U64 *) var->val.string);	875	(struct counter64 *) var->val.string);
876	break;	876	break;
877		877
878	/*	878	/*
Lines 889-898 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
889	* ipIfStatsHCOutRequests(21)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	889	* ipIfStatsHCOutRequests(21)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
890	*/	890	*/
891	case COLUMN_IPIFSTATSHCOUTREQUESTS:	891	case COLUMN_IPIFSTATSHCOUTREQUESTS:
892	var->val_len = sizeof(U64);	892	var->val_len = sizeof(struct counter64);
893	var->type = ASN_COUNTER64;	893	var->type = ASN_COUNTER64;
894	rc = ipIfStatsHCOutRequests_get(rowreq_ctx,	894	rc = ipIfStatsHCOutRequests_get(rowreq_ctx,
895	(U64 *) var->val.string);	895	(struct counter64 *) var->val.string);
896	break;	896	break;
897		897
898	/*	898	/*
Lines 909-918 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
909	* ipIfStatsHCOutForwDatagrams(24)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	909	* ipIfStatsHCOutForwDatagrams(24)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
910	*/	910	*/
911	case COLUMN_IPIFSTATSHCOUTFORWDATAGRAMS:	911	case COLUMN_IPIFSTATSHCOUTFORWDATAGRAMS:
912	var->val_len = sizeof(U64);	912	var->val_len = sizeof(struct counter64);
913	var->type = ASN_COUNTER64;	913	var->type = ASN_COUNTER64;
914	rc = ipIfStatsHCOutForwDatagrams_get(rowreq_ctx,	914	rc = ipIfStatsHCOutForwDatagrams_get(rowreq_ctx,
915	(U64 *) var->val.string);	915	(struct counter64 *) var->val.string);
916	break;	916	break;
917		917
918	/*	918	/*
Lines 979-988 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
979	* ipIfStatsHCOutTransmits(31)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	979	* ipIfStatsHCOutTransmits(31)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
980	*/	980	*/
981	case COLUMN_IPIFSTATSHCOUTTRANSMITS:	981	case COLUMN_IPIFSTATSHCOUTTRANSMITS:
982	var->val_len = sizeof(U64);	982	var->val_len = sizeof(struct counter64);
983	var->type = ASN_COUNTER64;	983	var->type = ASN_COUNTER64;
984	rc = ipIfStatsHCOutTransmits_get(rowreq_ctx,	984	rc = ipIfStatsHCOutTransmits_get(rowreq_ctx,
985	(U64 *) var->val.string);	985	(struct counter64 *) var->val.string);
986	break;	986	break;
987		987
988	/*	988	/*
Lines 999-1007 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
999	* ipIfStatsHCOutOctets(33)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	999	* ipIfStatsHCOutOctets(33)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1000	*/	1000	*/
1001	case COLUMN_IPIFSTATSHCOUTOCTETS:	1001	case COLUMN_IPIFSTATSHCOUTOCTETS:
1002	var->val_len = sizeof(U64);	1002	var->val_len = sizeof(struct counter64);
1003	var->type = ASN_COUNTER64;	1003	var->type = ASN_COUNTER64;
1004	rc = ipIfStatsHCOutOctets_get(rowreq_ctx, (U64 *) var->val.string);	1004	rc = ipIfStatsHCOutOctets_get(rowreq_ctx, (struct counter64 *) var->val.string);
1005	break;	1005	break;
1006		1006
1007	/*	1007	/*
Lines 1018-1027 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1018	* ipIfStatsHCInMcastPkts(35)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1018	* ipIfStatsHCInMcastPkts(35)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1019	*/	1019	*/
1020	case COLUMN_IPIFSTATSHCINMCASTPKTS:	1020	case COLUMN_IPIFSTATSHCINMCASTPKTS:
1021	var->val_len = sizeof(U64);	1021	var->val_len = sizeof(struct counter64);
1022	var->type = ASN_COUNTER64;	1022	var->type = ASN_COUNTER64;
1023	rc = ipIfStatsHCInMcastPkts_get(rowreq_ctx,	1023	rc = ipIfStatsHCInMcastPkts_get(rowreq_ctx,
1024	(U64 *) var->val.string);	1024	(struct counter64 *) var->val.string);
1025	break;	1025	break;
1026		1026
1027	/*	1027	/*
Lines 1038-1047 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1038	* ipIfStatsHCInMcastOctets(37)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1038	* ipIfStatsHCInMcastOctets(37)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1039	*/	1039	*/
1040	case COLUMN_IPIFSTATSHCINMCASTOCTETS:	1040	case COLUMN_IPIFSTATSHCINMCASTOCTETS:
1041	var->val_len = sizeof(U64);	1041	var->val_len = sizeof(struct counter64);
1042	var->type = ASN_COUNTER64;	1042	var->type = ASN_COUNTER64;
1043	rc = ipIfStatsHCInMcastOctets_get(rowreq_ctx,	1043	rc = ipIfStatsHCInMcastOctets_get(rowreq_ctx,
1044	(U64 *) var->val.string);	1044	(struct counter64 *) var->val.string);
1045	break;	1045	break;
1046		1046
1047	/*	1047	/*
Lines 1058-1067 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1058	* ipIfStatsHCOutMcastPkts(39)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1058	* ipIfStatsHCOutMcastPkts(39)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1059	*/	1059	*/
1060	case COLUMN_IPIFSTATSHCOUTMCASTPKTS:	1060	case COLUMN_IPIFSTATSHCOUTMCASTPKTS:
1061	var->val_len = sizeof(U64);	1061	var->val_len = sizeof(struct counter64);
1062	var->type = ASN_COUNTER64;	1062	var->type = ASN_COUNTER64;
1063	rc = ipIfStatsHCOutMcastPkts_get(rowreq_ctx,	1063	rc = ipIfStatsHCOutMcastPkts_get(rowreq_ctx,
1064	(U64 *) var->val.string);	1064	(struct counter64 *) var->val.string);
1065	break;	1065	break;
1066		1066
1067	/*	1067	/*
Lines 1078-1087 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1078	* ipIfStatsHCOutMcastOctets(41)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1078	* ipIfStatsHCOutMcastOctets(41)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1079	*/	1079	*/
1080	case COLUMN_IPIFSTATSHCOUTMCASTOCTETS:	1080	case COLUMN_IPIFSTATSHCOUTMCASTOCTETS:
1081	var->val_len = sizeof(U64);	1081	var->val_len = sizeof(struct counter64);
1082	var->type = ASN_COUNTER64;	1082	var->type = ASN_COUNTER64;
1083	rc = ipIfStatsHCOutMcastOctets_get(rowreq_ctx,	1083	rc = ipIfStatsHCOutMcastOctets_get(rowreq_ctx,
1084	(U64 *) var->val.string);	1084	(struct counter64 *) var->val.string);
1085	break;	1085	break;
1086		1086
1087	/*	1087	/*
Lines 1098-1107 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1098	* ipIfStatsHCInBcastPkts(43)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1098	* ipIfStatsHCInBcastPkts(43)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1099	*/	1099	*/
1100	case COLUMN_IPIFSTATSHCINBCASTPKTS:	1100	case COLUMN_IPIFSTATSHCINBCASTPKTS:
1101	var->val_len = sizeof(U64);	1101	var->val_len = sizeof(struct counter64);
1102	var->type = ASN_COUNTER64;	1102	var->type = ASN_COUNTER64;
1103	rc = ipIfStatsHCInBcastPkts_get(rowreq_ctx,	1103	rc = ipIfStatsHCInBcastPkts_get(rowreq_ctx,
1104	(U64 *) var->val.string);	1104	(struct counter64 *) var->val.string);
1105	break;	1105	break;
1106		1106
1107	/*	1107	/*
Lines 1118-1127 _ipIfStatsTable_get_column(ipIfStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1118	* ipIfStatsHCOutBcastPkts(45)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1118	* ipIfStatsHCOutBcastPkts(45)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1119	*/	1119	*/
1120	case COLUMN_IPIFSTATSHCOUTBCASTPKTS:	1120	case COLUMN_IPIFSTATSHCOUTBCASTPKTS:
1121	var->val_len = sizeof(U64);	1121	var->val_len = sizeof(struct counter64);
1122	var->type = ASN_COUNTER64;	1122	var->type = ASN_COUNTER64;
1123	rc = ipIfStatsHCOutBcastPkts_get(rowreq_ctx,	1123	rc = ipIfStatsHCOutBcastPkts_get(rowreq_ctx,
1124	(U64 *) var->val.string);	1124	(struct counter64 *) var->val.string);
1125	break;	1125	break;
1126		1126
1127	/*	1127	/*

Lines 722-728 The total number of octets received on the interface, Link Here

(-)a/agent/mibgroup/if-mib/ifXTable/ifXTable.c (-8 / +8 lines)
722	*/	722	*/
723	int	723	int
724	ifHCInOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,	724	ifHCInOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
725	U64 * ifHCInOctets_val_ptr)	725	struct counter64 *ifHCInOctets_val_ptr)
726	{	726	{
727	/** we should have a non-NULL pointer */	727	/** we should have a non-NULL pointer */
728	netsnmp_assert(NULL != ifHCInOctets_val_ptr);	728	netsnmp_assert(NULL != ifHCInOctets_val_ptr);
Lines 779-785 The number of packets, delivered by this sub-layer to a Link Here
779	*/	779	*/
780	int	780	int
781	ifHCInUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	781	ifHCInUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
782	U64 * ifHCInUcastPkts_val_ptr)	782	struct counter64 *ifHCInUcastPkts_val_ptr)
783	{	783	{
784	/** we should have a non-NULL pointer */	784	/** we should have a non-NULL pointer */
785	netsnmp_assert(NULL != ifHCInUcastPkts_val_ptr);	785	netsnmp_assert(NULL != ifHCInUcastPkts_val_ptr);
Lines 838-844 The number of packets, delivered by this sub-layer to a Link Here
838	*/	838	*/
839	int	839	int
840	ifHCInMulticastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	840	ifHCInMulticastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
841	U64 * ifHCInMulticastPkts_val_ptr)	841	struct counter64 *ifHCInMulticastPkts_val_ptr)
842	{	842	{
843	/** we should have a non-NULL pointer */	843	/** we should have a non-NULL pointer */
844	netsnmp_assert(NULL != ifHCInMulticastPkts_val_ptr);	844	netsnmp_assert(NULL != ifHCInMulticastPkts_val_ptr);
Lines 897-903 The number of packets, delivered by this sub-layer to a Link Here
897	*/	897	*/
898	int	898	int
899	ifHCInBroadcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	899	ifHCInBroadcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
900	U64 * ifHCInBroadcastPkts_val_ptr)	900	struct counter64 *ifHCInBroadcastPkts_val_ptr)
901	{	901	{
902	/** we should have a non-NULL pointer */	902	/** we should have a non-NULL pointer */
903	netsnmp_assert(NULL != ifHCInBroadcastPkts_val_ptr);	903	netsnmp_assert(NULL != ifHCInBroadcastPkts_val_ptr);
Lines 955-961 The total number of octets transmitted out of the Link Here
955	*/	955	*/
956	int	956	int
957	ifHCOutOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,	957	ifHCOutOctets_get(ifXTable_rowreq_ctx * rowreq_ctx,
958	U64 * ifHCOutOctets_val_ptr)	958	struct counter64 *ifHCOutOctets_val_ptr)
959	{	959	{
960	/** we should have a non-NULL pointer */	960	/** we should have a non-NULL pointer */
961	netsnmp_assert(NULL != ifHCOutOctets_val_ptr);	961	netsnmp_assert(NULL != ifHCOutOctets_val_ptr);
Lines 1013-1019 The total number of packets that higher-level protocols Link Here
1013	*/	1013	*/
1014	int	1014	int
1015	ifHCOutUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	1015	ifHCOutUcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
1016	U64 * ifHCOutUcastPkts_val_ptr)	1016	struct counter64 *ifHCOutUcastPkts_val_ptr)
1017	{	1017	{
1018	/** we should have a non-NULL pointer */	1018	/** we should have a non-NULL pointer */
1019	netsnmp_assert(NULL != ifHCOutUcastPkts_val_ptr);	1019	netsnmp_assert(NULL != ifHCOutUcastPkts_val_ptr);
Lines 1074-1080 The total number of packets that higher-level protocols Link Here
1074	*/	1074	*/
1075	int	1075	int
1076	ifHCOutMulticastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	1076	ifHCOutMulticastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
1077	U64 * ifHCOutMulticastPkts_val_ptr)	1077	struct counter64 *ifHCOutMulticastPkts_val_ptr)
1078	{	1078	{
1079	/** we should have a non-NULL pointer */	1079	/** we should have a non-NULL pointer */
1080	netsnmp_assert(NULL != ifHCOutMulticastPkts_val_ptr);	1080	netsnmp_assert(NULL != ifHCOutMulticastPkts_val_ptr);
Lines 1134-1140 The total number of packets that higher-level protocols Link Here
1134	*/	1134	*/
1135	int	1135	int
1136	ifHCOutBroadcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,	1136	ifHCOutBroadcastPkts_get(ifXTable_rowreq_ctx * rowreq_ctx,
1137	U64 * ifHCOutBroadcastPkts_val_ptr)	1137	struct counter64 *ifHCOutBroadcastPkts_val_ptr)
1138	{	1138	{
1139	/** we should have a non-NULL pointer */	1139	/** we should have a non-NULL pointer */
1140	netsnmp_assert(NULL != ifHCOutBroadcastPkts_val_ptr);	1140	netsnmp_assert(NULL != ifHCOutBroadcastPkts_val_ptr);

Lines 270-276 The total number of input IP datagrams received, including Link Here

(-)a/agent/mibgroup/ip-mib/ipIfStatsTable/ipIfStatsTable_data_get.c (-14 / +14 lines)
270	*/	270	*/
271	int	271	int
272	ipIfStatsHCInReceives_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	272	ipIfStatsHCInReceives_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
273	U64 * ipIfStatsHCInReceives_val_ptr)	273	struct counter64 *ipIfStatsHCInReceives_val_ptr)
274	{	274	{
275	/** we should have a non-NULL pointer */	275	/** we should have a non-NULL pointer */
276	netsnmp_assert(NULL != ipIfStatsHCInReceives_val_ptr);	276	netsnmp_assert(NULL != ipIfStatsHCInReceives_val_ptr);
Lines 395-401 The total number of octets received in input IP datagrams, Link Here
395	*/	395	*/
396	int	396	int
397	ipIfStatsHCInOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	397	ipIfStatsHCInOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
398	U64 * ipIfStatsHCInOctets_val_ptr)	398	struct counter64 *ipIfStatsHCInOctets_val_ptr)
399	{	399	{
400	/** we should have a non-NULL pointer */	400	/** we should have a non-NULL pointer */
401	netsnmp_assert(NULL != ipIfStatsHCInOctets_val_ptr);	401	netsnmp_assert(NULL != ipIfStatsHCInOctets_val_ptr);
Lines 862-868 The number of input datagrams for which this entity was not Link Here
862	*/	862	*/
863	int	863	int
864	ipIfStatsHCInForwDatagrams_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	864	ipIfStatsHCInForwDatagrams_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
865	U64 * ipIfStatsHCInForwDatagrams_val_ptr)	865	struct counter64 *ipIfStatsHCInForwDatagrams_val_ptr)
866	{	866	{
867	/** we should have a non-NULL pointer */	867	/** we should have a non-NULL pointer */
868	netsnmp_assert(NULL != ipIfStatsHCInForwDatagrams_val_ptr);	868	netsnmp_assert(NULL != ipIfStatsHCInForwDatagrams_val_ptr);
Lines 1267-1273 The total number of datagrams successfully delivered to IP Link Here
1267	*/	1267	*/
1268	int	1268	int
1269	ipIfStatsHCInDelivers_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	1269	ipIfStatsHCInDelivers_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
1270	U64 * ipIfStatsHCInDelivers_val_ptr)	1270	struct counter64 *ipIfStatsHCInDelivers_val_ptr)
1271	{	1271	{
1272	/** we should have a non-NULL pointer */	1272	/** we should have a non-NULL pointer */
1273	netsnmp_assert(NULL != ipIfStatsHCInDelivers_val_ptr);	1273	netsnmp_assert(NULL != ipIfStatsHCInDelivers_val_ptr);
Lines 1396-1402 The total number of IP datagrams that local IP user- Link Here
1396	*/	1396	*/
1397	int	1397	int
1398	ipIfStatsHCOutRequests_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	1398	ipIfStatsHCOutRequests_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
1399	U64 * ipIfStatsHCOutRequests_val_ptr)	1399	struct counter64 *ipIfStatsHCOutRequests_val_ptr)
1400	{	1400	{
1401	/** we should have a non-NULL pointer */	1401	/** we should have a non-NULL pointer */
1402	netsnmp_assert(NULL != ipIfStatsHCOutRequests_val_ptr);	1402	netsnmp_assert(NULL != ipIfStatsHCOutRequests_val_ptr);
Lines 1532-1538 The number of datagrams for which this entity was not their Link Here
1532	*/	1532	*/
1533	int	1533	int
1534	ipIfStatsHCOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	1534	ipIfStatsHCOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
1535	U64 * ipIfStatsHCOutForwDatagrams_val_ptr)	1535	struct counter64 *ipIfStatsHCOutForwDatagrams_val_ptr)
1536	{	1536	{
1537	/** we should have a non-NULL pointer */	1537	/** we should have a non-NULL pointer */
1538	netsnmp_assert(NULL != ipIfStatsHCOutForwDatagrams_val_ptr);	1538	netsnmp_assert(NULL != ipIfStatsHCOutForwDatagrams_val_ptr);
Lines 1999-2005 The total number of IP datagrams that this entity supplied Link Here
1999	*/	1999	*/
2000	int	2000	int
2001	ipIfStatsHCOutTransmits_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2001	ipIfStatsHCOutTransmits_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2002	U64 * ipIfStatsHCOutTransmits_val_ptr)	2002	struct counter64 *ipIfStatsHCOutTransmits_val_ptr)
2003	{	2003	{
2004	/** we should have a non-NULL pointer */	2004	/** we should have a non-NULL pointer */
2005	netsnmp_assert(NULL != ipIfStatsHCOutTransmits_val_ptr);	2005	netsnmp_assert(NULL != ipIfStatsHCOutTransmits_val_ptr);
Lines 2123-2129 The total number of octets in IP datagrams delivered to the Link Here
2123	*/	2123	*/
2124	int	2124	int
2125	ipIfStatsHCOutOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2125	ipIfStatsHCOutOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2126	U64 * ipIfStatsHCOutOctets_val_ptr)	2126	struct counter64 *ipIfStatsHCOutOctets_val_ptr)
2127	{	2127	{
2128	/** we should have a non-NULL pointer */	2128	/** we should have a non-NULL pointer */
2129	netsnmp_assert(NULL != ipIfStatsHCOutOctets_val_ptr);	2129	netsnmp_assert(NULL != ipIfStatsHCOutOctets_val_ptr);
Lines 2245-2251 The number of IP multicast datagrams received. This object Link Here
2245	*/	2245	*/
2246	int	2246	int
2247	ipIfStatsHCInMcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2247	ipIfStatsHCInMcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2248	U64 * ipIfStatsHCInMcastPkts_val_ptr)	2248	struct counter64 *ipIfStatsHCInMcastPkts_val_ptr)
2249	{	2249	{
2250	/** we should have a non-NULL pointer */	2250	/** we should have a non-NULL pointer */
2251	netsnmp_assert(NULL != ipIfStatsHCInMcastPkts_val_ptr);	2251	netsnmp_assert(NULL != ipIfStatsHCInMcastPkts_val_ptr);
Lines 2372-2378 The total number of octets received in IP multicast Link Here
2372	*/	2372	*/
2373	int	2373	int
2374	ipIfStatsHCInMcastOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2374	ipIfStatsHCInMcastOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2375	U64 * ipIfStatsHCInMcastOctets_val_ptr)	2375	struct counter64 *ipIfStatsHCInMcastOctets_val_ptr)
2376	{	2376	{
2377	/** we should have a non-NULL pointer */	2377	/** we should have a non-NULL pointer */
2378	netsnmp_assert(NULL != ipIfStatsHCInMcastOctets_val_ptr);	2378	netsnmp_assert(NULL != ipIfStatsHCInMcastOctets_val_ptr);
Lines 2497-2503 The number of IP multicast datagrams transmitted. This Link Here
2497	*/	2497	*/
2498	int	2498	int
2499	ipIfStatsHCOutMcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2499	ipIfStatsHCOutMcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2500	U64 * ipIfStatsHCOutMcastPkts_val_ptr)	2500	struct counter64 *ipIfStatsHCOutMcastPkts_val_ptr)
2501	{	2501	{
2502	/** we should have a non-NULL pointer */	2502	/** we should have a non-NULL pointer */
2503	netsnmp_assert(NULL != ipIfStatsHCOutMcastPkts_val_ptr);	2503	netsnmp_assert(NULL != ipIfStatsHCOutMcastPkts_val_ptr);
Lines 2621-2627 The total number of octets transmitted in IP multicast Link Here
2621	*/	2621	*/
2622	int	2622	int
2623	ipIfStatsHCOutMcastOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2623	ipIfStatsHCOutMcastOctets_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2624	U64 * ipIfStatsHCOutMcastOctets_val_ptr)	2624	struct counter64 *ipIfStatsHCOutMcastOctets_val_ptr)
2625	{	2625	{
2626	/** we should have a non-NULL pointer */	2626	/** we should have a non-NULL pointer */
2627	netsnmp_assert(NULL != ipIfStatsHCOutMcastOctets_val_ptr);	2627	netsnmp_assert(NULL != ipIfStatsHCOutMcastOctets_val_ptr);
Lines 2743-2749 The number of IP broadcast datagrams received. This object Link Here
2743	*/	2743	*/
2744	int	2744	int
2745	ipIfStatsHCInBcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2745	ipIfStatsHCInBcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2746	U64 * ipIfStatsHCInBcastPkts_val_ptr)	2746	struct counter64 *ipIfStatsHCInBcastPkts_val_ptr)
2747	{	2747	{
2748	/** we should have a non-NULL pointer */	2748	/** we should have a non-NULL pointer */
2749	netsnmp_assert(NULL != ipIfStatsHCInBcastPkts_val_ptr);	2749	netsnmp_assert(NULL != ipIfStatsHCInBcastPkts_val_ptr);
Lines 2865-2871 The number of IP broadcast datagrams transmitted. This Link Here
2865	*/	2865	*/
2866	int	2866	int
2867	ipIfStatsHCOutBcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,	2867	ipIfStatsHCOutBcastPkts_get(ipIfStatsTable_rowreq_ctx * rowreq_ctx,
2868	U64 * ipIfStatsHCOutBcastPkts_val_ptr)	2868	struct counter64 *ipIfStatsHCOutBcastPkts_val_ptr)
2869	{	2869	{
2870	/** we should have a non-NULL pointer */	2870	/** we should have a non-NULL pointer */
2871	netsnmp_assert(NULL != ipIfStatsHCOutBcastPkts_val_ptr);	2871	netsnmp_assert(NULL != ipIfStatsHCOutBcastPkts_val_ptr);

Lines 50-56 extern "C" { Link Here

(-)a/agent/mibgroup/ip-mib/ipIfStatsTable/ipIfStatsTable_data_get.h (-14 / +14 lines)
50	ipIfStatsInReceives_val_ptr);	50	ipIfStatsInReceives_val_ptr);
51	int ipIfStatsHCInReceives_get(ipIfStatsTable_rowreq_ctx *	51	int ipIfStatsHCInReceives_get(ipIfStatsTable_rowreq_ctx *
52	rowreq_ctx,	52	rowreq_ctx,
53	U64 *	53	struct counter64 *
54	ipIfStatsHCInReceives_val_ptr);	54	ipIfStatsHCInReceives_val_ptr);
55	int ipIfStatsInOctets_get(ipIfStatsTable_rowreq_ctx *	55	int ipIfStatsInOctets_get(ipIfStatsTable_rowreq_ctx *
56	rowreq_ctx,	56	rowreq_ctx,
Lines 58-64 extern "C" { Link Here
58	ipIfStatsInOctets_val_ptr);	58	ipIfStatsInOctets_val_ptr);
59	int ipIfStatsHCInOctets_get(ipIfStatsTable_rowreq_ctx *	59	int ipIfStatsHCInOctets_get(ipIfStatsTable_rowreq_ctx *
60	rowreq_ctx,	60	rowreq_ctx,
61	U64 *	61	struct counter64 *
62	ipIfStatsHCInOctets_val_ptr);	62	ipIfStatsHCInOctets_val_ptr);
63	int ipIfStatsInHdrErrors_get(ipIfStatsTable_rowreq_ctx *	63	int ipIfStatsInHdrErrors_get(ipIfStatsTable_rowreq_ctx *
64	rowreq_ctx,	64	rowreq_ctx,
Lines 87-93 extern "C" { Link Here
87	int	87	int
88	ipIfStatsHCInForwDatagrams_get(ipIfStatsTable_rowreq_ctx *	88	ipIfStatsHCInForwDatagrams_get(ipIfStatsTable_rowreq_ctx *
89	rowreq_ctx,	89	rowreq_ctx,
90	U64 *	90	struct counter64 *
91	ipIfStatsHCInForwDatagrams_val_ptr);	91	ipIfStatsHCInForwDatagrams_val_ptr);
92	int ipIfStatsReasmReqds_get(ipIfStatsTable_rowreq_ctx *	92	int ipIfStatsReasmReqds_get(ipIfStatsTable_rowreq_ctx *
93	rowreq_ctx,	93	rowreq_ctx,
Lines 111-117 extern "C" { Link Here
111	ipIfStatsInDelivers_val_ptr);	111	ipIfStatsInDelivers_val_ptr);
112	int ipIfStatsHCInDelivers_get(ipIfStatsTable_rowreq_ctx *	112	int ipIfStatsHCInDelivers_get(ipIfStatsTable_rowreq_ctx *
113	rowreq_ctx,	113	rowreq_ctx,
114	U64 *	114	struct counter64 *
115	ipIfStatsHCInDelivers_val_ptr);	115	ipIfStatsHCInDelivers_val_ptr);
116	int ipIfStatsOutRequests_get(ipIfStatsTable_rowreq_ctx *	116	int ipIfStatsOutRequests_get(ipIfStatsTable_rowreq_ctx *
117	rowreq_ctx,	117	rowreq_ctx,
Lines 119-125 extern "C" { Link Here
119	ipIfStatsOutRequests_val_ptr);	119	ipIfStatsOutRequests_val_ptr);
120	int ipIfStatsHCOutRequests_get(ipIfStatsTable_rowreq_ctx *	120	int ipIfStatsHCOutRequests_get(ipIfStatsTable_rowreq_ctx *
121	rowreq_ctx,	121	rowreq_ctx,
122	U64 *	122	struct counter64 *
123	ipIfStatsHCOutRequests_val_ptr);	123	ipIfStatsHCOutRequests_val_ptr);
124	int ipIfStatsOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx	124	int ipIfStatsOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx
125	* rowreq_ctx,	125	* rowreq_ctx,
Lines 128-134 extern "C" { Link Here
128	int	128	int
129	ipIfStatsHCOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx *	129	ipIfStatsHCOutForwDatagrams_get(ipIfStatsTable_rowreq_ctx *
130	rowreq_ctx,	130	rowreq_ctx,
131	U64 *	131	struct counter64 *
132	ipIfStatsHCOutForwDatagrams_val_ptr);	132	ipIfStatsHCOutForwDatagrams_val_ptr);
133	int ipIfStatsOutDiscards_get(ipIfStatsTable_rowreq_ctx *	133	int ipIfStatsOutDiscards_get(ipIfStatsTable_rowreq_ctx *
134	rowreq_ctx,	134	rowreq_ctx,
Lines 156-162 extern "C" { Link Here
156	ipIfStatsOutTransmits_val_ptr);	156	ipIfStatsOutTransmits_val_ptr);
157	int ipIfStatsHCOutTransmits_get(ipIfStatsTable_rowreq_ctx *	157	int ipIfStatsHCOutTransmits_get(ipIfStatsTable_rowreq_ctx *
158	rowreq_ctx,	158	rowreq_ctx,
159	U64 *	159	struct counter64 *
160	ipIfStatsHCOutTransmits_val_ptr);	160	ipIfStatsHCOutTransmits_val_ptr);
161	int ipIfStatsOutOctets_get(ipIfStatsTable_rowreq_ctx *	161	int ipIfStatsOutOctets_get(ipIfStatsTable_rowreq_ctx *
162	rowreq_ctx,	162	rowreq_ctx,
Lines 164-170 extern "C" { Link Here
164	ipIfStatsOutOctets_val_ptr);	164	ipIfStatsOutOctets_val_ptr);
165	int ipIfStatsHCOutOctets_get(ipIfStatsTable_rowreq_ctx *	165	int ipIfStatsHCOutOctets_get(ipIfStatsTable_rowreq_ctx *
166	rowreq_ctx,	166	rowreq_ctx,
167	U64 *	167	struct counter64 *
168	ipIfStatsHCOutOctets_val_ptr);	168	ipIfStatsHCOutOctets_val_ptr);
169	int ipIfStatsInMcastPkts_get(ipIfStatsTable_rowreq_ctx *	169	int ipIfStatsInMcastPkts_get(ipIfStatsTable_rowreq_ctx *
170	rowreq_ctx,	170	rowreq_ctx,
Lines 172-178 extern "C" { Link Here
172	ipIfStatsInMcastPkts_val_ptr);	172	ipIfStatsInMcastPkts_val_ptr);
173	int ipIfStatsHCInMcastPkts_get(ipIfStatsTable_rowreq_ctx *	173	int ipIfStatsHCInMcastPkts_get(ipIfStatsTable_rowreq_ctx *
174	rowreq_ctx,	174	rowreq_ctx,
175	U64 *	175	struct counter64 *
176	ipIfStatsHCInMcastPkts_val_ptr);	176	ipIfStatsHCInMcastPkts_val_ptr);
177	int ipIfStatsInMcastOctets_get(ipIfStatsTable_rowreq_ctx *	177	int ipIfStatsInMcastOctets_get(ipIfStatsTable_rowreq_ctx *
178	rowreq_ctx,	178	rowreq_ctx,
Lines 180-186 extern "C" { Link Here
180	ipIfStatsInMcastOctets_val_ptr);	180	ipIfStatsInMcastOctets_val_ptr);
181	int ipIfStatsHCInMcastOctets_get(ipIfStatsTable_rowreq_ctx	181	int ipIfStatsHCInMcastOctets_get(ipIfStatsTable_rowreq_ctx
182	* rowreq_ctx,	182	* rowreq_ctx,
183	U64 *	183	struct counter64 *
184	ipIfStatsHCInMcastOctets_val_ptr);	184	ipIfStatsHCInMcastOctets_val_ptr);
185	int ipIfStatsOutMcastPkts_get(ipIfStatsTable_rowreq_ctx *	185	int ipIfStatsOutMcastPkts_get(ipIfStatsTable_rowreq_ctx *
186	rowreq_ctx,	186	rowreq_ctx,
Lines 188-194 extern "C" { Link Here
188	ipIfStatsOutMcastPkts_val_ptr);	188	ipIfStatsOutMcastPkts_val_ptr);
189	int ipIfStatsHCOutMcastPkts_get(ipIfStatsTable_rowreq_ctx *	189	int ipIfStatsHCOutMcastPkts_get(ipIfStatsTable_rowreq_ctx *
190	rowreq_ctx,	190	rowreq_ctx,
191	U64 *	191	struct counter64 *
192	ipIfStatsHCOutMcastPkts_val_ptr);	192	ipIfStatsHCOutMcastPkts_val_ptr);
193	int ipIfStatsOutMcastOctets_get(ipIfStatsTable_rowreq_ctx *	193	int ipIfStatsOutMcastOctets_get(ipIfStatsTable_rowreq_ctx *
194	rowreq_ctx,	194	rowreq_ctx,
Lines 196-202 extern "C" { Link Here
196	ipIfStatsOutMcastOctets_val_ptr);	196	ipIfStatsOutMcastOctets_val_ptr);
197	int ipIfStatsHCOutMcastOctets_get(ipIfStatsTable_rowreq_ctx	197	int ipIfStatsHCOutMcastOctets_get(ipIfStatsTable_rowreq_ctx
198	* rowreq_ctx,	198	* rowreq_ctx,
199	U64 *	199	struct counter64 *
200	ipIfStatsHCOutMcastOctets_val_ptr);	200	ipIfStatsHCOutMcastOctets_val_ptr);
201	int ipIfStatsInBcastPkts_get(ipIfStatsTable_rowreq_ctx *	201	int ipIfStatsInBcastPkts_get(ipIfStatsTable_rowreq_ctx *
202	rowreq_ctx,	202	rowreq_ctx,
Lines 204-210 extern "C" { Link Here
204	ipIfStatsInBcastPkts_val_ptr);	204	ipIfStatsInBcastPkts_val_ptr);
205	int ipIfStatsHCInBcastPkts_get(ipIfStatsTable_rowreq_ctx *	205	int ipIfStatsHCInBcastPkts_get(ipIfStatsTable_rowreq_ctx *
206	rowreq_ctx,	206	rowreq_ctx,
207	U64 *	207	struct counter64 *
208	ipIfStatsHCInBcastPkts_val_ptr);	208	ipIfStatsHCInBcastPkts_val_ptr);
209	int ipIfStatsOutBcastPkts_get(ipIfStatsTable_rowreq_ctx *	209	int ipIfStatsOutBcastPkts_get(ipIfStatsTable_rowreq_ctx *
210	rowreq_ctx,	210	rowreq_ctx,
Lines 212-218 extern "C" { Link Here
212	ipIfStatsOutBcastPkts_val_ptr);	212	ipIfStatsOutBcastPkts_val_ptr);
213	int ipIfStatsHCOutBcastPkts_get(ipIfStatsTable_rowreq_ctx *	213	int ipIfStatsHCOutBcastPkts_get(ipIfStatsTable_rowreq_ctx *
214	rowreq_ctx,	214	rowreq_ctx,
215	U64 *	215	struct counter64 *
216	ipIfStatsHCOutBcastPkts_val_ptr);	216	ipIfStatsHCOutBcastPkts_val_ptr);
217	int	217	int
218	ipIfStatsDiscontinuityTime_get(ipIfStatsTable_rowreq_ctx *	218	ipIfStatsDiscontinuityTime_get(ipIfStatsTable_rowreq_ctx *

Lines 452-458 The total number of input IP datagrams received, including Link Here

(-)a/agent/mibgroup/ip-mib/ipSystemStatsTable/ipSystemStatsTable.c (-14 / +14 lines)
452	*/	452	*/
453	int	453	int
454	ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	454	ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
455	U64 * ipSystemStatsHCInReceives_val_ptr)	455	struct counter64 *ipSystemStatsHCInReceives_val_ptr)
456	{	456	{
457	/** we should have a non-NULL pointer */	457	/** we should have a non-NULL pointer */
458	netsnmp_assert(NULL != ipSystemStatsHCInReceives_val_ptr);	458	netsnmp_assert(NULL != ipSystemStatsHCInReceives_val_ptr);
Lines 579-585 The total number of octets received in input IP datagrams, Link Here
579	*/	579	*/
580	int	580	int
581	ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	581	ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
582	U64 * ipSystemStatsHCInOctets_val_ptr)	582	struct counter64 *ipSystemStatsHCInOctets_val_ptr)
583	{	583	{
584	/** we should have a non-NULL pointer */	584	/** we should have a non-NULL pointer */
585	netsnmp_assert(NULL != ipSystemStatsHCInOctets_val_ptr);	585	netsnmp_assert(NULL != ipSystemStatsHCInOctets_val_ptr);
Lines 1058-1064 The number of input datagrams for which this entity was not Link Here
1058	int	1058	int
1059	ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *	1059	ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
1060	rowreq_ctx,	1060	rowreq_ctx,
1061	U64 *	1061	struct counter64 *
1062	ipSystemStatsHCInForwDatagrams_val_ptr)	1062	ipSystemStatsHCInForwDatagrams_val_ptr)
1063	{	1063	{
1064	/** we should have a non-NULL pointer */	1064	/** we should have a non-NULL pointer */
Lines 1474-1480 The total number of datagrams successfully delivered to IP Link Here
1474	*/	1474	*/
1475	int	1475	int
1476	ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	1476	ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
1477	U64 * ipSystemStatsHCInDelivers_val_ptr)	1477	struct counter64 *ipSystemStatsHCInDelivers_val_ptr)
1478	{	1478	{
1479	/** we should have a non-NULL pointer */	1479	/** we should have a non-NULL pointer */
1480	netsnmp_assert(NULL != ipSystemStatsHCInDelivers_val_ptr);	1480	netsnmp_assert(NULL != ipSystemStatsHCInDelivers_val_ptr);
Lines 1602-1608 The total number of IP datagrams which local IP user- Link Here
1602	*/	1602	*/
1603	int	1603	int
1604	ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	1604	ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
1605	U64 * ipSystemStatsHCOutRequests_val_ptr)	1605	struct counter64 *ipSystemStatsHCOutRequests_val_ptr)
1606	{	1606	{
1607	/** we should have a non-NULL pointer */	1607	/** we should have a non-NULL pointer */
1608	netsnmp_assert(NULL != ipSystemStatsHCOutRequests_val_ptr);	1608	netsnmp_assert(NULL != ipSystemStatsHCOutRequests_val_ptr);
Lines 1809-1815 The number of datagrams for which this entity was not their Link Here
1809	int	1809	int
1810	ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *	1810	ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
1811	rowreq_ctx,	1811	rowreq_ctx,
1812	U64 *	1812	struct counter64 *
1813	ipSystemStatsHCOutForwDatagrams_val_ptr)	1813	ipSystemStatsHCOutForwDatagrams_val_ptr)
1814	{	1814	{
1815	/** we should have a non-NULL pointer */	1815	/** we should have a non-NULL pointer */
Lines 2288-2294 The total number of IP datagrams that this entity supplied Link Here
2288	*/	2288	*/
2289	int	2289	int
2290	ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	2290	ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
2291	U64 * ipSystemStatsHCOutTransmits_val_ptr)	2291	struct counter64 *ipSystemStatsHCOutTransmits_val_ptr)
2292	{	2292	{
2293	/** we should have a non-NULL pointer */	2293	/** we should have a non-NULL pointer */
2294	netsnmp_assert(NULL != ipSystemStatsHCOutTransmits_val_ptr);	2294	netsnmp_assert(NULL != ipSystemStatsHCOutTransmits_val_ptr);
Lines 2415-2421 The total number of octets in IP datagrams delivered to the Link Here
2415	*/	2415	*/
2416	int	2416	int
2417	ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	2417	ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
2418	U64 * ipSystemStatsHCOutOctets_val_ptr)	2418	struct counter64 *ipSystemStatsHCOutOctets_val_ptr)
2419	{	2419	{
2420	/** we should have a non-NULL pointer */	2420	/** we should have a non-NULL pointer */
2421	netsnmp_assert(NULL != ipSystemStatsHCOutOctets_val_ptr);	2421	netsnmp_assert(NULL != ipSystemStatsHCOutOctets_val_ptr);
Lines 2539-2545 The number of IP multicast datagrams received. This object Link Here
2539	*/	2539	*/
2540	int	2540	int
2541	ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	2541	ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
2542	U64 * ipSystemStatsHCInMcastPkts_val_ptr)	2542	struct counter64 *ipSystemStatsHCInMcastPkts_val_ptr)
2543	{	2543	{
2544	/** we should have a non-NULL pointer */	2544	/** we should have a non-NULL pointer */
2545	netsnmp_assert(NULL != ipSystemStatsHCInMcastPkts_val_ptr);	2545	netsnmp_assert(NULL != ipSystemStatsHCInMcastPkts_val_ptr);
Lines 2665-2671 The total number of octets received in IP multicast Link Here
2665	int	2665	int
2666	ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *	2666	ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
2667	rowreq_ctx,	2667	rowreq_ctx,
2668	U64 *	2668	struct counter64 *
2669	ipSystemStatsHCInMcastOctets_val_ptr)	2669	ipSystemStatsHCInMcastOctets_val_ptr)
2670	{	2670	{
2671	/** we should have a non-NULL pointer */	2671	/** we should have a non-NULL pointer */
Lines 2790-2796 The number of IP multicast datagrams transmitted. This Link Here
2790	*/	2790	*/
2791	int	2791	int
2792	ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	2792	ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
2793	U64 * ipSystemStatsHCOutMcastPkts_val_ptr)	2793	struct counter64 *ipSystemStatsHCOutMcastPkts_val_ptr)
2794	{	2794	{
2795	/** we should have a non-NULL pointer */	2795	/** we should have a non-NULL pointer */
2796	netsnmp_assert(NULL != ipSystemStatsHCOutMcastPkts_val_ptr);	2796	netsnmp_assert(NULL != ipSystemStatsHCOutMcastPkts_val_ptr);
Lines 2921-2927 The total number of octets transmitted in IP multicast Link Here
2921	int	2921	int
2922	ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *	2922	ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
2923	rowreq_ctx,	2923	rowreq_ctx,
2924	U64 *	2924	struct counter64 *
2925	ipSystemStatsHCOutMcastOctets_val_ptr)	2925	ipSystemStatsHCOutMcastOctets_val_ptr)
2926	{	2926	{
2927	/** we should have a non-NULL pointer */	2927	/** we should have a non-NULL pointer */
Lines 3046-3052 The number of IP broadcast datagrams received. This object Link Here
3046	*/	3046	*/
3047	int	3047	int
3048	ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	3048	ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
3049	U64 * ipSystemStatsHCInBcastPkts_val_ptr)	3049	struct counter64 *ipSystemStatsHCInBcastPkts_val_ptr)
3050	{	3050	{
3051	/** we should have a non-NULL pointer */	3051	/** we should have a non-NULL pointer */
3052	netsnmp_assert(NULL != ipSystemStatsHCInBcastPkts_val_ptr);	3052	netsnmp_assert(NULL != ipSystemStatsHCInBcastPkts_val_ptr);
Lines 3170-3176 The number of IP broadcast datagrams transmitted. This Link Here
3170	*/	3170	*/
3171	int	3171	int
3172	ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,	3172	ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx * rowreq_ctx,
3173	U64 * ipSystemStatsHCOutBcastPkts_val_ptr)	3173	struct counter64 *ipSystemStatsHCOutBcastPkts_val_ptr)
3174	{	3174	{
3175	/** we should have a non-NULL pointer */	3175	/** we should have a non-NULL pointer */
3176	netsnmp_assert(NULL != ipSystemStatsHCOutBcastPkts_val_ptr);	3176	netsnmp_assert(NULL != ipSystemStatsHCOutBcastPkts_val_ptr);

Lines 144-236 config_require(ip-mib/ipSystemStatsTable/ipSystemStatsTable_data_access) Link Here

(-)a/agent/mibgroup/ip-mib/ipSystemStatsTable/ipSystemStatsTable.h (-858 / +63 lines)
144	*********************************************************************	144	*********************************************************************
145	* function prototypes	145	* function prototypes
146	*/	146	*/
147	int	147	int ipSystemStatsTable_pre_request(ipSystemStatsTable_registration *
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163	ipSystemStatsTable_pre_request(ipSystemStatsTable_registration *
164	user_context);	148	user_context);
165	int	149	int ipSystemStatsTable_post_request(ipSystemStatsTable_registration *
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181	ipSystemStatsTable_post_request(ipSystemStatsTable_registration *
182	user_context, int rc);	150	user_context, int rc);
183		151
184	int	152	int ipSystemStatsTable_rowreq_ctx_init(ipSystemStatsTable_rowreq_ctx *
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200	ipSystemStatsTable_rowreq_ctx_init(ipSystemStatsTable_rowreq_ctx *
201	rowreq_ctx,	153	rowreq_ctx,
202	void *user_init_ctx);	154	void *user_init_ctx);
203	void	155	void
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219	ipSystemStatsTable_rowreq_ctx_cleanup(ipSystemStatsTable_rowreq_ctx	156	ipSystemStatsTable_rowreq_ctx_cleanup(ipSystemStatsTable_rowreq_ctx
220	* rowreq_ctx);	157	* rowreq_ctx);
221		158
222	ipSystemStatsTable_data *ipSystemStatsTable_allocate_data(void);	159	ipSystemStatsTable_data *ipSystemStatsTable_allocate_data(void);
223	void ipSystemStatsTable_release_data(ipSystemStatsTable_data	160	void ipSystemStatsTable_release_data(ipSystemStatsTable_data
224	* data);	161	* data);
225		162	ipSystemStatsTable_rowreq_ctx
226
227
228
229
230
231
232
233	ipSystemStatsTable_rowreq_ctx
234	* ipSystemStatsTable_row_find_by_mib_index	163	* ipSystemStatsTable_row_find_by_mib_index
235	(ipSystemStatsTable_mib_index * mib_idx);	164	(ipSystemStatsTable_mib_index * mib_idx);
236		165
Lines 265-490 config_require(ip-mib/ipSystemStatsTable/ipSystemStatsTable_data_access) Link Here
265	* indexes	194	* indexes
266	*/	195	*/
267		196
268	int	197	int ipSystemStatsInReceives_get(ipSystemStatsTable_rowreq_ctx *
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284	ipSystemStatsInReceives_get(ipSystemStatsTable_rowreq_ctx *
285	rowreq_ctx,	198	rowreq_ctx,
286	u_long *	199	u_long *
287	ipSystemStatsInReceives_val_ptr);	200	ipSystemStatsInReceives_val_ptr);
288	int	201	int ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx *
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304	ipSystemStatsHCInReceives_get(ipSystemStatsTable_rowreq_ctx *
305	rowreq_ctx,	202	rowreq_ctx,
306	U64 *	203	struct counter64 *
307	ipSystemStatsHCInReceives_val_ptr);	204	ipSystemStatsHCInReceives_val_ptr);
308	int ipSystemStatsInOctets_get(ipSystemStatsTable_rowreq_ctx	205	int ipSystemStatsInOctets_get(ipSystemStatsTable_rowreq_ctx
309	* rowreq_ctx,	206	* rowreq_ctx,
310	u_long *	207	u_long *
311	ipSystemStatsInOctets_val_ptr);	208	ipSystemStatsInOctets_val_ptr);
312	int	209	int ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx *
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328	ipSystemStatsHCInOctets_get(ipSystemStatsTable_rowreq_ctx *
329	rowreq_ctx,	210	rowreq_ctx,
330	U64 * ipSystemStatsHCInOctets_val_ptr);	211	struct counter64 *ipSystemStatsHCInOctets_val_ptr);
331	int	212	int ipSystemStatsInHdrErrors_get(ipSystemStatsTable_rowreq_ctx *
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347	ipSystemStatsInHdrErrors_get(ipSystemStatsTable_rowreq_ctx *
348	rowreq_ctx,	213	rowreq_ctx,
349	u_long *	214	u_long *
350	ipSystemStatsInHdrErrors_val_ptr);	215	ipSystemStatsInHdrErrors_val_ptr);
351	int	216	int ipSystemStatsInNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367	ipSystemStatsInNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
368	rowreq_ctx,	217	rowreq_ctx,
369	u_long *	218	u_long *
370	ipSystemStatsInNoRoutes_val_ptr);	219	ipSystemStatsInNoRoutes_val_ptr);
371	int	220	int ipSystemStatsInAddrErrors_get(ipSystemStatsTable_rowreq_ctx *
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387	ipSystemStatsInAddrErrors_get(ipSystemStatsTable_rowreq_ctx *
388	rowreq_ctx,	221	rowreq_ctx,
389	u_long *	222	u_long *
390	ipSystemStatsInAddrErrors_val_ptr);	223	ipSystemStatsInAddrErrors_val_ptr);
391	int	224	int ipSystemStatsInUnknownProtos_get(ipSystemStatsTable_rowreq_ctx *
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407	ipSystemStatsInUnknownProtos_get(ipSystemStatsTable_rowreq_ctx *
408	rowreq_ctx,	225	rowreq_ctx,
409	u_long *	226	u_long *
410	ipSystemStatsInUnknownProtos_val_ptr);	227	ipSystemStatsInUnknownProtos_val_ptr);
411	int	228	int ipSystemStatsInTruncatedPkts_get(ipSystemStatsTable_rowreq_ctx *
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427	ipSystemStatsInTruncatedPkts_get(ipSystemStatsTable_rowreq_ctx *
428	rowreq_ctx,	229	rowreq_ctx,
429	u_long *	230	u_long *
430	ipSystemStatsInTruncatedPkts_val_ptr);	231	ipSystemStatsInTruncatedPkts_val_ptr);
431	int	232	int ipSystemStatsInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447	ipSystemStatsInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
448	rowreq_ctx,	233	rowreq_ctx,
449	u_long *	234	u_long *
450	ipSystemStatsInForwDatagrams_val_ptr);	235	ipSystemStatsInForwDatagrams_val_ptr);
451	int	236	int ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467	ipSystemStatsHCInForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
468	rowreq_ctx,	237	rowreq_ctx,
469	U64 *	238	struct counter64 *
470	ipSystemStatsHCInForwDatagrams_val_ptr);	239	ipSystemStatsHCInForwDatagrams_val_ptr);
471	int	240	int ipSystemStatsReasmReqds_get(ipSystemStatsTable_rowreq_ctx *
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487	ipSystemStatsReasmReqds_get(ipSystemStatsTable_rowreq_ctx *
488	rowreq_ctx,	241	rowreq_ctx,
489	u_long *	242	u_long *
490	ipSystemStatsReasmReqds_val_ptr);	243	ipSystemStatsReasmReqds_val_ptr);
Lines 492-1181 config_require(ip-mib/ipSystemStatsTable/ipSystemStatsTable_data_access) Link Here
492	* rowreq_ctx,	245	* rowreq_ctx,
493	u_long *	246	u_long *
494	ipSystemStatsReasmOKs_val_ptr);	247	ipSystemStatsReasmOKs_val_ptr);
495	int	248	int ipSystemStatsReasmFails_get(ipSystemStatsTable_rowreq_ctx *
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511	ipSystemStatsReasmFails_get(ipSystemStatsTable_rowreq_ctx *
512	rowreq_ctx,	249	rowreq_ctx,
513	u_long *	250	u_long *
514	ipSystemStatsReasmFails_val_ptr);	251	ipSystemStatsReasmFails_val_ptr);
515	int	252	int ipSystemStatsInDiscards_get(ipSystemStatsTable_rowreq_ctx *
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531	ipSystemStatsInDiscards_get(ipSystemStatsTable_rowreq_ctx *
532	rowreq_ctx,	253	rowreq_ctx,
533	u_long *	254	u_long *
534	ipSystemStatsInDiscards_val_ptr);	255	ipSystemStatsInDiscards_val_ptr);
535	int	256	int ipSystemStatsInDelivers_get(ipSystemStatsTable_rowreq_ctx *
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551	ipSystemStatsInDelivers_get(ipSystemStatsTable_rowreq_ctx *
552	rowreq_ctx,	257	rowreq_ctx,
553	u_long *	258	u_long *
554	ipSystemStatsInDelivers_val_ptr);	259	ipSystemStatsInDelivers_val_ptr);
555	int	260	int ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx *
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571	ipSystemStatsHCInDelivers_get(ipSystemStatsTable_rowreq_ctx *
572	rowreq_ctx,	261	rowreq_ctx,
573	U64 *	262	struct counter64 *
574	ipSystemStatsHCInDelivers_val_ptr);	263	ipSystemStatsHCInDelivers_val_ptr);
575	int	264	int ipSystemStatsOutRequests_get(ipSystemStatsTable_rowreq_ctx *
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591	ipSystemStatsOutRequests_get(ipSystemStatsTable_rowreq_ctx *
592	rowreq_ctx,	265	rowreq_ctx,
593	u_long *	266	u_long *
594	ipSystemStatsOutRequests_val_ptr);	267	ipSystemStatsOutRequests_val_ptr);
595	int	268	int ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx *
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611	ipSystemStatsHCOutRequests_get(ipSystemStatsTable_rowreq_ctx *
612	rowreq_ctx,	269	rowreq_ctx,
613	U64 *	270	struct counter64 *
614	ipSystemStatsHCOutRequests_val_ptr);	271	ipSystemStatsHCOutRequests_val_ptr);
615	int	272	int ipSystemStatsOutNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631	ipSystemStatsOutNoRoutes_get(ipSystemStatsTable_rowreq_ctx *
632	rowreq_ctx,	273	rowreq_ctx,
633	u_long *	274	u_long *
634	ipSystemStatsOutNoRoutes_val_ptr);	275	ipSystemStatsOutNoRoutes_val_ptr);
635	int	276	int ipSystemStatsOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651	ipSystemStatsOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
652	rowreq_ctx,	277	rowreq_ctx,
653	u_long *	278	u_long *
654	ipSystemStatsOutForwDatagrams_val_ptr);	279	ipSystemStatsOutForwDatagrams_val_ptr);
655	int	280	int ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671	ipSystemStatsHCOutForwDatagrams_get(ipSystemStatsTable_rowreq_ctx *
672	rowreq_ctx,	281	rowreq_ctx,
673	U64 *	282	struct counter64 *
674	ipSystemStatsHCOutForwDatagrams_val_ptr);	283	ipSystemStatsHCOutForwDatagrams_val_ptr);
675	int	284	int ipSystemStatsOutDiscards_get(ipSystemStatsTable_rowreq_ctx *
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691	ipSystemStatsOutDiscards_get(ipSystemStatsTable_rowreq_ctx *
692	rowreq_ctx,	285	rowreq_ctx,
693	u_long *	286	u_long *
694	ipSystemStatsOutDiscards_val_ptr);	287	ipSystemStatsOutDiscards_val_ptr);
695	int	288	int ipSystemStatsOutFragReqds_get(ipSystemStatsTable_rowreq_ctx *
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711	ipSystemStatsOutFragReqds_get(ipSystemStatsTable_rowreq_ctx *
712	rowreq_ctx,	289	rowreq_ctx,
713	u_long *	290	u_long *
714	ipSystemStatsOutFragReqds_val_ptr);	291	ipSystemStatsOutFragReqds_val_ptr);
715	int	292	int ipSystemStatsOutFragOKs_get(ipSystemStatsTable_rowreq_ctx *
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731	ipSystemStatsOutFragOKs_get(ipSystemStatsTable_rowreq_ctx *
732	rowreq_ctx,	293	rowreq_ctx,
733	u_long *	294	u_long *
734	ipSystemStatsOutFragOKs_val_ptr);	295	ipSystemStatsOutFragOKs_val_ptr);
735	int	296	int ipSystemStatsOutFragFails_get(ipSystemStatsTable_rowreq_ctx *
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751	ipSystemStatsOutFragFails_get(ipSystemStatsTable_rowreq_ctx *
752	rowreq_ctx,	297	rowreq_ctx,
753	u_long *	298	u_long *
754	ipSystemStatsOutFragFails_val_ptr);	299	ipSystemStatsOutFragFails_val_ptr);
755	int	300	int ipSystemStatsOutFragCreates_get(ipSystemStatsTable_rowreq_ctx *
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771	ipSystemStatsOutFragCreates_get(ipSystemStatsTable_rowreq_ctx *
772	rowreq_ctx,	301	rowreq_ctx,
773	u_long *	302	u_long *
774	ipSystemStatsOutFragCreates_val_ptr);	303	ipSystemStatsOutFragCreates_val_ptr);
775	int	304	int ipSystemStatsOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791	ipSystemStatsOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
792	rowreq_ctx,	305	rowreq_ctx,
793	u_long *	306	u_long *
794	ipSystemStatsOutTransmits_val_ptr);	307	ipSystemStatsOutTransmits_val_ptr);
795	int	308	int ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811	ipSystemStatsHCOutTransmits_get(ipSystemStatsTable_rowreq_ctx *
812	rowreq_ctx,	309	rowreq_ctx,
813	U64 *	310	struct counter64 *
814	ipSystemStatsHCOutTransmits_val_ptr);	311	ipSystemStatsHCOutTransmits_val_ptr);
815	int	312	int ipSystemStatsOutOctets_get(ipSystemStatsTable_rowreq_ctx *
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831	ipSystemStatsOutOctets_get(ipSystemStatsTable_rowreq_ctx *
832	rowreq_ctx,	313	rowreq_ctx,
833	u_long *	314	u_long *
834	ipSystemStatsOutOctets_val_ptr);	315	ipSystemStatsOutOctets_val_ptr);
835	int	316	int ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx *
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851	ipSystemStatsHCOutOctets_get(ipSystemStatsTable_rowreq_ctx *
852	rowreq_ctx,	317	rowreq_ctx,
853	U64 *	318	struct counter64 *
854	ipSystemStatsHCOutOctets_val_ptr);	319	ipSystemStatsHCOutOctets_val_ptr);
855	int	320	int ipSystemStatsInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871	ipSystemStatsInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
872	rowreq_ctx,	321	rowreq_ctx,
873	u_long *	322	u_long *
874	ipSystemStatsInMcastPkts_val_ptr);	323	ipSystemStatsInMcastPkts_val_ptr);
875	int	324	int ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891	ipSystemStatsHCInMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
892	rowreq_ctx,	325	rowreq_ctx,
893	U64 *	326	struct counter64 *
894	ipSystemStatsHCInMcastPkts_val_ptr);	327	ipSystemStatsHCInMcastPkts_val_ptr);
895	int	328	int ipSystemStatsInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911	ipSystemStatsInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
912	rowreq_ctx,	329	rowreq_ctx,
913	u_long *	330	u_long *
914	ipSystemStatsInMcastOctets_val_ptr);	331	ipSystemStatsInMcastOctets_val_ptr);
915	int	332	int ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931	ipSystemStatsHCInMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
932	rowreq_ctx,	333	rowreq_ctx,
933	U64 *	334	struct counter64 *
934	ipSystemStatsHCInMcastOctets_val_ptr);	335	ipSystemStatsHCInMcastOctets_val_ptr);
935	int	336	int ipSystemStatsOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951	ipSystemStatsOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
952	rowreq_ctx,	337	rowreq_ctx,
953	u_long *	338	u_long *
954	ipSystemStatsOutMcastPkts_val_ptr);	339	ipSystemStatsOutMcastPkts_val_ptr);
955	int	340	int ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971	ipSystemStatsHCOutMcastPkts_get(ipSystemStatsTable_rowreq_ctx *
972	rowreq_ctx,	341	rowreq_ctx,
973	U64 *	342	struct counter64 *
974	ipSystemStatsHCOutMcastPkts_val_ptr);	343	ipSystemStatsHCOutMcastPkts_val_ptr);
975	int	344	int ipSystemStatsOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991	ipSystemStatsOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
992	rowreq_ctx,	345	rowreq_ctx,
993	u_long *	346	u_long *
994	ipSystemStatsOutMcastOctets_val_ptr);	347	ipSystemStatsOutMcastOctets_val_ptr);
995	int	348	int ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011	ipSystemStatsHCOutMcastOctets_get(ipSystemStatsTable_rowreq_ctx *
1012	rowreq_ctx,	349	rowreq_ctx,
1013	U64 *	350	struct counter64 *
1014	ipSystemStatsHCOutMcastOctets_val_ptr);	351	ipSystemStatsHCOutMcastOctets_val_ptr);
1015	int	352	int ipSystemStatsInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031	ipSystemStatsInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1032	rowreq_ctx,	353	rowreq_ctx,
1033	u_long *	354	u_long *
1034	ipSystemStatsInBcastPkts_val_ptr);	355	ipSystemStatsInBcastPkts_val_ptr);
1035	int	356	int ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051	ipSystemStatsHCInBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1052	rowreq_ctx,	357	rowreq_ctx,
1053	U64 *	358	struct counter64 *
1054	ipSystemStatsHCInBcastPkts_val_ptr);	359	ipSystemStatsHCInBcastPkts_val_ptr);
1055	int	360	int ipSystemStatsOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071	ipSystemStatsOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1072	rowreq_ctx,	361	rowreq_ctx,
1073	u_long *	362	u_long *
1074	ipSystemStatsOutBcastPkts_val_ptr);	363	ipSystemStatsOutBcastPkts_val_ptr);
1075	int	364	int ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091	ipSystemStatsHCOutBcastPkts_get(ipSystemStatsTable_rowreq_ctx *
1092	rowreq_ctx,	365	rowreq_ctx,
1093	U64 *	366	struct counter64 *
1094	ipSystemStatsHCOutBcastPkts_val_ptr);	367	ipSystemStatsHCOutBcastPkts_val_ptr);
1095	int	368	int ipSystemStatsDiscontinuityTime_get(ipSystemStatsTable_rowreq_ctx *
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111	ipSystemStatsDiscontinuityTime_get(ipSystemStatsTable_rowreq_ctx *
1112	rowreq_ctx,	369	rowreq_ctx,
1113	u_long *	370	u_long *
1114	ipSystemStatsDiscontinuityTime_val_ptr);	371	ipSystemStatsDiscontinuityTime_val_ptr);
1115	int	372	int ipSystemStatsRefreshRate_get(ipSystemStatsTable_rowreq_ctx *
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131	ipSystemStatsRefreshRate_get(ipSystemStatsTable_rowreq_ctx *
1132	rowreq_ctx,	373	rowreq_ctx,
1133	u_long *	374	u_long *
1134	ipSystemStatsRefreshRate_val_ptr);	375	ipSystemStatsRefreshRate_val_ptr);
1135		376	int ipSystemStatsTable_indexes_set_tbl_idx(ipSystemStatsTable_mib_index
1136
1137	int
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153	ipSystemStatsTable_indexes_set_tbl_idx(ipSystemStatsTable_mib_index
1154	* tbl_idx,	377	* tbl_idx,
1155	u_long	378	u_long
1156	ipSystemStatsIPVersion_val);	379	ipSystemStatsIPVersion_val);
1157	int	380	int ipSystemStatsTable_indexes_set(ipSystemStatsTable_rowreq_ctx *
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173	ipSystemStatsTable_indexes_set(ipSystemStatsTable_rowreq_ctx *
1174	rowreq_ctx,	381	rowreq_ctx,
1175	u_long ipSystemStatsIPVersion_val);	382	u_long ipSystemStatsIPVersion_val);
1176		383
1177
1178
1179	/*	384	/*
1180	*********************************************************************	385	*********************************************************************
1181	* SET function declarations	386	* SET function declarations

Lines 674-683 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here

(-)a/agent/mibgroup/ip-mib/ipSystemStatsTable/ipSystemStatsTable_interface.c (-28 / +28 lines)
674	* ipSystemStatsHCInReceives(4)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	674	* ipSystemStatsHCInReceives(4)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
675	*/	675	*/
676	case COLUMN_IPSYSTEMSTATSHCINRECEIVES:	676	case COLUMN_IPSYSTEMSTATSHCINRECEIVES:
677	var->val_len = sizeof(U64);	677	var->val_len = sizeof(struct counter64);
678	var->type = ASN_COUNTER64;	678	var->type = ASN_COUNTER64;
679	rc = ipSystemStatsHCInReceives_get(rowreq_ctx,	679	rc = ipSystemStatsHCInReceives_get(rowreq_ctx,
680	(U64 *) var->val.string);	680	(struct counter64 *) var->val.string);
681	break;	681	break;
682		682
683	/*	683	/*
Lines 694-703 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
694	* ipSystemStatsHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	694	* ipSystemStatsHCInOctets(6)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
695	*/	695	*/
696	case COLUMN_IPSYSTEMSTATSHCINOCTETS:	696	case COLUMN_IPSYSTEMSTATSHCINOCTETS:
697	var->val_len = sizeof(U64);	697	var->val_len = sizeof(struct counter64);
698	var->type = ASN_COUNTER64;	698	var->type = ASN_COUNTER64;
699	rc = ipSystemStatsHCInOctets_get(rowreq_ctx,	699	rc = ipSystemStatsHCInOctets_get(rowreq_ctx,
700	(U64 *) var->val.string);	700	(struct counter64 *) var->val.string);
701	break;	701	break;
702		702
703	/*	703	/*
Lines 764-773 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
764	* ipSystemStatsHCInForwDatagrams(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	764	* ipSystemStatsHCInForwDatagrams(13)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
765	*/	765	*/
766	case COLUMN_IPSYSTEMSTATSHCINFORWDATAGRAMS:	766	case COLUMN_IPSYSTEMSTATSHCINFORWDATAGRAMS:
767	var->val_len = sizeof(U64);	767	var->val_len = sizeof(struct counter64);
768	var->type = ASN_COUNTER64;	768	var->type = ASN_COUNTER64;
769	rc = ipSystemStatsHCInForwDatagrams_get(rowreq_ctx,	769	rc = ipSystemStatsHCInForwDatagrams_get(rowreq_ctx,
770	(U64 *) var->val.string);	770	(struct counter64 *) var->val.string);
771	break;	771	break;
772		772
773	/*	773	/*
Lines 824-833 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
824	* ipSystemStatsHCInDelivers(19)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	824	* ipSystemStatsHCInDelivers(19)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
825	*/	825	*/
826	case COLUMN_IPSYSTEMSTATSHCINDELIVERS:	826	case COLUMN_IPSYSTEMSTATSHCINDELIVERS:
827	var->val_len = sizeof(U64);	827	var->val_len = sizeof(struct counter64);
828	var->type = ASN_COUNTER64;	828	var->type = ASN_COUNTER64;
829	rc = ipSystemStatsHCInDelivers_get(rowreq_ctx,	829	rc = ipSystemStatsHCInDelivers_get(rowreq_ctx,
830	(U64 *) var->val.string);	830	(struct counter64 *) var->val.string);
831	break;	831	break;
832		832
833	/*	833	/*
Lines 844-853 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
844	* ipSystemStatsHCOutRequests(21)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	844	* ipSystemStatsHCOutRequests(21)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
845	*/	845	*/
846	case COLUMN_IPSYSTEMSTATSHCOUTREQUESTS:	846	case COLUMN_IPSYSTEMSTATSHCOUTREQUESTS:
847	var->val_len = sizeof(U64);	847	var->val_len = sizeof(struct counter64);
848	var->type = ASN_COUNTER64;	848	var->type = ASN_COUNTER64;
849	rc = ipSystemStatsHCOutRequests_get(rowreq_ctx,	849	rc = ipSystemStatsHCOutRequests_get(rowreq_ctx,
850	(U64 *) var->val.string);	850	(struct counter64 *) var->val.string);
851	break;	851	break;
852		852
853	/*	853	/*
Lines 874-883 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
874	* ipSystemStatsHCOutForwDatagrams(24)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	874	* ipSystemStatsHCOutForwDatagrams(24)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
875	*/	875	*/
876	case COLUMN_IPSYSTEMSTATSHCOUTFORWDATAGRAMS:	876	case COLUMN_IPSYSTEMSTATSHCOUTFORWDATAGRAMS:
877	var->val_len = sizeof(U64);	877	var->val_len = sizeof(struct counter64);
878	var->type = ASN_COUNTER64;	878	var->type = ASN_COUNTER64;
879	rc = ipSystemStatsHCOutForwDatagrams_get(rowreq_ctx,	879	rc = ipSystemStatsHCOutForwDatagrams_get(rowreq_ctx,
880	(U64 *) var->val.string);	880	(struct counter64 *) var->val.string);
881	break;	881	break;
882		882
883	/*	883	/*
Lines 944-953 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
944	* ipSystemStatsHCOutTransmits(31)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	944	* ipSystemStatsHCOutTransmits(31)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
945	*/	945	*/
946	case COLUMN_IPSYSTEMSTATSHCOUTTRANSMITS:	946	case COLUMN_IPSYSTEMSTATSHCOUTTRANSMITS:
947	var->val_len = sizeof(U64);	947	var->val_len = sizeof(struct counter64);
948	var->type = ASN_COUNTER64;	948	var->type = ASN_COUNTER64;
949	rc = ipSystemStatsHCOutTransmits_get(rowreq_ctx,	949	rc = ipSystemStatsHCOutTransmits_get(rowreq_ctx,
950	(U64 *) var->val.string);	950	(struct counter64 *) var->val.string);
951	break;	951	break;
952		952
953	/*	953	/*
Lines 964-973 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
964	* ipSystemStatsHCOutOctets(33)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	964	* ipSystemStatsHCOutOctets(33)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
965	*/	965	*/
966	case COLUMN_IPSYSTEMSTATSHCOUTOCTETS:	966	case COLUMN_IPSYSTEMSTATSHCOUTOCTETS:
967	var->val_len = sizeof(U64);	967	var->val_len = sizeof(struct counter64);
968	var->type = ASN_COUNTER64;	968	var->type = ASN_COUNTER64;
969	rc = ipSystemStatsHCOutOctets_get(rowreq_ctx,	969	rc = ipSystemStatsHCOutOctets_get(rowreq_ctx,
970	(U64 *) var->val.string);	970	(struct counter64 *) var->val.string);
971	break;	971	break;
972		972
973	/*	973	/*
Lines 984-993 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
984	* ipSystemStatsHCInMcastPkts(35)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	984	* ipSystemStatsHCInMcastPkts(35)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
985	*/	985	*/
986	case COLUMN_IPSYSTEMSTATSHCINMCASTPKTS:	986	case COLUMN_IPSYSTEMSTATSHCINMCASTPKTS:
987	var->val_len = sizeof(U64);	987	var->val_len = sizeof(struct counter64);
988	var->type = ASN_COUNTER64;	988	var->type = ASN_COUNTER64;
989	rc = ipSystemStatsHCInMcastPkts_get(rowreq_ctx,	989	rc = ipSystemStatsHCInMcastPkts_get(rowreq_ctx,
990	(U64 *) var->val.string);	990	(struct counter64 *) var->val.string);
991	break;	991	break;
992		992
993	/*	993	/*
Lines 1004-1013 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1004	* ipSystemStatsHCInMcastOctets(37)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1004	* ipSystemStatsHCInMcastOctets(37)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1005	*/	1005	*/
1006	case COLUMN_IPSYSTEMSTATSHCINMCASTOCTETS:	1006	case COLUMN_IPSYSTEMSTATSHCINMCASTOCTETS:
1007	var->val_len = sizeof(U64);	1007	var->val_len = sizeof(struct counter64);
1008	var->type = ASN_COUNTER64;	1008	var->type = ASN_COUNTER64;
1009	rc = ipSystemStatsHCInMcastOctets_get(rowreq_ctx,	1009	rc = ipSystemStatsHCInMcastOctets_get(rowreq_ctx,
1010	(U64 *) var->val.string);	1010	(struct counter64 *) var->val.string);
1011	break;	1011	break;
1012		1012
1013	/*	1013	/*
Lines 1024-1033 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1024	* ipSystemStatsHCOutMcastPkts(39)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1024	* ipSystemStatsHCOutMcastPkts(39)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1025	*/	1025	*/
1026	case COLUMN_IPSYSTEMSTATSHCOUTMCASTPKTS:	1026	case COLUMN_IPSYSTEMSTATSHCOUTMCASTPKTS:
1027	var->val_len = sizeof(U64);	1027	var->val_len = sizeof(struct counter64);
1028	var->type = ASN_COUNTER64;	1028	var->type = ASN_COUNTER64;
1029	rc = ipSystemStatsHCOutMcastPkts_get(rowreq_ctx,	1029	rc = ipSystemStatsHCOutMcastPkts_get(rowreq_ctx,
1030	(U64 *) var->val.string);	1030	(struct counter64 *) var->val.string);
1031	break;	1031	break;
1032		1032
1033	/*	1033	/*
Lines 1044-1053 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1044	* ipSystemStatsHCOutMcastOctets(41)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1044	* ipSystemStatsHCOutMcastOctets(41)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1045	*/	1045	*/
1046	case COLUMN_IPSYSTEMSTATSHCOUTMCASTOCTETS:	1046	case COLUMN_IPSYSTEMSTATSHCOUTMCASTOCTETS:
1047	var->val_len = sizeof(U64);	1047	var->val_len = sizeof(struct counter64);
1048	var->type = ASN_COUNTER64;	1048	var->type = ASN_COUNTER64;
1049	rc = ipSystemStatsHCOutMcastOctets_get(rowreq_ctx,	1049	rc = ipSystemStatsHCOutMcastOctets_get(rowreq_ctx,
1050	(U64 *) var->val.string);	1050	(struct counter64 *) var->val.string);
1051	break;	1051	break;
1052		1052
1053	/*	1053	/*
Lines 1064-1073 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1064	* ipSystemStatsHCInBcastPkts(43)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1064	* ipSystemStatsHCInBcastPkts(43)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1065	*/	1065	*/
1066	case COLUMN_IPSYSTEMSTATSHCINBCASTPKTS:	1066	case COLUMN_IPSYSTEMSTATSHCINBCASTPKTS:
1067	var->val_len = sizeof(U64);	1067	var->val_len = sizeof(struct counter64);
1068	var->type = ASN_COUNTER64;	1068	var->type = ASN_COUNTER64;
1069	rc = ipSystemStatsHCInBcastPkts_get(rowreq_ctx,	1069	rc = ipSystemStatsHCInBcastPkts_get(rowreq_ctx,
1070	(U64 *) var->val.string);	1070	(struct counter64 *) var->val.string);
1071	break;	1071	break;
1072		1072
1073	/*	1073	/*
Lines 1084-1093 _ipSystemStatsTable_get_column(ipSystemStatsTable_rowreq_ctx * rowreq_ctx, Link Here
1084	* ipSystemStatsHCOutBcastPkts(45)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h	1084	* ipSystemStatsHCOutBcastPkts(45)/COUNTER64/ASN_COUNTER64/U64(U64)//l/A/w/e/r/d/h
1085	*/	1085	*/
1086	case COLUMN_IPSYSTEMSTATSHCOUTBCASTPKTS:	1086	case COLUMN_IPSYSTEMSTATSHCOUTBCASTPKTS:
1087	var->val_len = sizeof(U64);	1087	var->val_len = sizeof(struct counter64);
1088	var->type = ASN_COUNTER64;	1088	var->type = ASN_COUNTER64;
1089	rc = ipSystemStatsHCOutBcastPkts_get(rowreq_ctx,	1089	rc = ipSystemStatsHCOutBcastPkts_get(rowreq_ctx,
1090	(U64 *) var->val.string);	1090	(struct counter64 *) var->val.string);
1091	break;	1091	break;
1092		1092
1093	/*	1093	/*

Lines 58-102 typedef struct netsnmp_ipstats_s { Link Here

(-)a/include/net-snmp/data_access/ipstats.h (-21 / +21 lines)
58	* other columns, when underlying OS does not provide them.	58	* other columns, when underlying OS does not provide them.
59	* Always fill at least 32 bits, the table is periodically polled -> 32 bit	59	* Always fill at least 32 bits, the table is periodically polled -> 32 bit
60	* overflow shall be detected and 64 bit value should be computed automatically. */	60	* overflow shall be detected and 64 bit value should be computed automatically. */
61	U64 HCInReceives;	61	struct counter64 HCInReceives;
62	U64 HCInOctets;	62	struct counter64 HCInOctets;
63	u_long InHdrErrors;	63	u_long InHdrErrors;
64	U64 HCInNoRoutes;	64	struct counter64 HCInNoRoutes;
65	u_long InAddrErrors;	65	u_long InAddrErrors;
66	u_long InUnknownProtos;	66	u_long InUnknownProtos;
67	u_long InTruncatedPkts;	67	u_long InTruncatedPkts;
68		68
69	/* optional, can be computed from HCInNoRoutes and HCOutForwDatagrams */	69	/* optional, can be computed from HCInNoRoutes and HCOutForwDatagrams */
70	U64 HCInForwDatagrams;	70	struct counter64 HCInForwDatagrams;
71		71
72	u_long ReasmReqds;	72	u_long ReasmReqds;
73	u_long ReasmOKs;	73	u_long ReasmOKs;
74	u_long ReasmFails;	74	u_long ReasmFails;
75	u_long InDiscards;	75	u_long InDiscards;
76	U64 HCInDelivers;	76	struct counter64 HCInDelivers;
77	U64 HCOutRequests;	77	struct counter64 HCOutRequests;
78	U64 HCOutNoRoutes;	78	struct counter64 HCOutNoRoutes;
79	U64 HCOutForwDatagrams;	79	struct counter64 HCOutForwDatagrams;
80	U64 HCOutDiscards;	80	struct counter64 HCOutDiscards;
81		81
82	/* optional, can be computed from HCOutFragOKs + HCOutFragFails*/	82	/* optional, can be computed from HCOutFragOKs + HCOutFragFails*/
83	U64 HCOutFragReqds;	83	struct counter64 HCOutFragReqds;
84	U64 HCOutFragOKs;	84	struct counter64 HCOutFragOKs;
85	U64 HCOutFragFails;	85	struct counter64 HCOutFragFails;
86	U64 HCOutFragCreates;	86	struct counter64 HCOutFragCreates;
87		87
88	/* optional, can be computed from	88	/* optional, can be computed from
89	* HCOutRequests +HCOutForwDatagrams + HCOutFragCreates	89	* HCOutRequests +HCOutForwDatagrams + HCOutFragCreates
90	* - HCOutFragReqds - HCOutNoRoutes - HCOutDiscards */	90	* - HCOutFragReqds - HCOutNoRoutes - HCOutDiscards */
91	U64 HCOutTransmits;	91	struct counter64 HCOutTransmits;
92		92
93	U64 HCOutOctets;	93	struct counter64 HCOutOctets;
94	U64 HCInMcastPkts;	94	struct counter64 HCInMcastPkts;
95	U64 HCInMcastOctets;	95	struct counter64 HCInMcastOctets;
96	U64 HCOutMcastPkts;	96	struct counter64 HCOutMcastPkts;
97	U64 HCOutMcastOctets;	97	struct counter64 HCOutMcastOctets;
98	U64 HCInBcastPkts;	98	struct counter64 HCInBcastPkts;
99	U64 HCOutBcastPkts;	99	struct counter64 HCOutBcastPkts;
100		100
101	/* Array of available columns.*/	101	/* Array of available columns.*/
102	int columnAvail[IPSYSTEMSTATSTABLE_LAST+1];	102	int columnAvail[IPSYSTEMSTATSTABLE_LAST+1];

Lines 5-35 Link Here

(-)a/include/net-snmp/library/int64.h (-18 / +16 lines)
5	extern "C" {	5	extern "C" {
6	#endif	6	#endif
7		7
8	typedef struct counter64 U64;
9
10	#define I64CHARSZ 21	8	#define I64CHARSZ 21
11		9
12	void divBy10(U64, U64 , unsigned int );	10	void divBy10(struct counter64, struct counter64 , unsigned int );
13	void multBy10(U64, U64 *);	11	void multBy10(struct counter64, struct counter64 *);
14	void incrByU16(U64 *, unsigned int);	12	void incrByU16(struct counter64 *, unsigned int);
15	void incrByU32(U64 *, unsigned int);	13	void incrByU32(struct counter64 *, unsigned int);
16	NETSNMP_IMPORT	14	NETSNMP_IMPORT
17	void zeroU64(U64 *);	15	void zeroU64(struct counter64 *);
18	int isZeroU64(const U64 *);	16	int isZeroU64(const struct counter64 *);
19	NETSNMP_IMPORT	17	NETSNMP_IMPORT
20	void printU64(char , const U64 );	18	void printU64(char , const struct counter64 );
21	NETSNMP_IMPORT	19	NETSNMP_IMPORT
22	void printI64(char , const U64 );	20	void printI64(char , const struct counter64 );
23	int read64(U64 , const char );	21	int read64(struct counter64 , const char );
24	NETSNMP_IMPORT	22	NETSNMP_IMPORT
25	void u64Subtract(const U64 * pu64one, const U64 * pu64two,	23	void u64Subtract(const struct counter64 pu64one, const struct counter64 pu64two,
26	U64 * pu64out);	24	struct counter64 *pu64out);
27	void u64Incr(U64 * pu64out, const U64 * pu64one);	25	void u64Incr(struct counter64 pu64out, const struct counter64 pu64one);
28	void u64UpdateCounter(U64 * pu64out, const U64 * pu64one,	26	void u64UpdateCounter(struct counter64 pu64out, const struct counter64 pu64one,
29	const U64 * pu64two);	27	const struct counter64 *pu64two);
30	void u64Copy(U64 * pu64one, const U64 * pu64two);	28	void u64Copy(struct counter64 pu64one, const struct counter64 pu64two);
31		29
32	int netsnmp_c64_check_for_32bit_wrap(U64 old_val, U64 new_val,	30	int netsnmp_c64_check_for_32bit_wrap(struct counter64 old_val, struct counter64 new_val,
33	int adjust);	31	int adjust);
34	NETSNMP_IMPORT	32	NETSNMP_IMPORT
35	int netsnmp_c64_check32_and_update(struct counter64 *prev_val,	33	int netsnmp_c64_check32_and_update(struct counter64 *prev_val,

Lines 33-39 Link Here

(-)a/snmplib/int64.c (-19 / +19 lines)
33	* @param[out] puR Remainder.	33	* @param[out] puR Remainder.
34	*/	34	*/
35	void	35	void
36	divBy10(U64 u64, U64 * pu64Q, unsigned int *puR)	36	divBy10(struct counter64 u64, struct counter64 pu64Q, unsigned int puR)
37	{	37	{
38	unsigned long ulT;	38	unsigned long ulT;
39	unsigned long ulQ;	39	unsigned long ulQ;
Lines 83-89 divBy10(U64 u64, U64 * pu64Q, unsigned int *puR) Link Here
83	* @param[out] pu64P Product.	83	* @param[out] pu64P Product.
84	*/	84	*/
85	void	85	void
86	multBy10(U64 u64, U64 * pu64P)	86	multBy10(struct counter64 u64, struct counter64 *pu64P)
87	{	87	{
88	unsigned long ulT;	88	unsigned long ulT;
89	unsigned long ulP;	89	unsigned long ulP;
Lines 130-136 multBy10(U64 u64, U64 * pu64P) Link Here
130	*	130	*
131	*/	131	*/
132	void	132	void
133	incrByU16(U64 * pu64, unsigned int u16)	133	incrByU16(struct counter64 *pu64, unsigned int u16)
134	{	134	{
135	incrByU32(pu64, u16);	135	incrByU32(pu64, u16);
136	}	136	}
Lines 143-149 incrByU16(U64 * pu64, unsigned int u16) Link Here
143	*	143	*
144	*/	144	*/
145	void	145	void
146	incrByU32(U64 * pu64, unsigned int u32)	146	incrByU32(struct counter64 *pu64, unsigned int u32)
147	{	147	{
148	uint32_t tmp;	148	uint32_t tmp;
149		149
Lines 161-167 incrByU32(U64 * pu64, unsigned int u32) Link Here
161	* @param[out] pu64out pu64one - pu64two.	161	* @param[out] pu64out pu64one - pu64two.
162	*/	162	*/
163	void	163	void
164	u64Subtract(const U64 * pu64one, const U64 * pu64two, U64 * pu64out)	164	u64Subtract(const struct counter64 pu64one, const struct counter64 pu64two, struct counter64 *pu64out)
165	{	165	{
166	int carry;	166	int carry;
167		167
Lines 177-183 u64Subtract(const U64 * pu64one, const U64 * pu64two, U64 * pu64out) Link Here
177	* @param[in,out] pu64out pu64out += pu64one.	177	* @param[in,out] pu64out pu64out += pu64one.
178	*/	178	*/
179	void	179	void
180	u64Incr(U64 * pu64out, const U64 * pu64one)	180	u64Incr(struct counter64 pu64out, const struct counter64 pu64one)
181	{	181	{
182	pu64out->high = (uint32_t)(pu64out->high + pu64one->high);	182	pu64out->high = (uint32_t)(pu64out->high + pu64one->high);
183	incrByU32(pu64out, pu64one->low);	183	incrByU32(pu64out, pu64one->low);
Lines 191-199 u64Incr(U64 * pu64out, const U64 * pu64one) Link Here
191	* @param[out] pu64out pu64out += (pu64one - pu64two)	191	* @param[out] pu64out pu64out += (pu64one - pu64two)
192	*/	192	*/
193	void	193	void
194	u64UpdateCounter(U64 * pu64out, const U64 * pu64one, const U64 * pu64two)	194	u64UpdateCounter(struct counter64 pu64out, const struct counter64 pu64one, const struct counter64 *pu64two)
195	{	195	{
196	U64 tmp;	196	struct counter64 tmp;
197		197
198	u64Subtract(pu64one, pu64two, &tmp);	198	u64Subtract(pu64one, pu64two, &tmp);
199	u64Incr(pu64out, &tmp);	199	u64Incr(pu64out, &tmp);
Lines 208-214 netsnmp_feature_child_of(u64copy, netsnmp_unused) Link Here
208	* @param[out] pu64one Where to store the copy - pu64one = pu64two.	208	* @param[out] pu64one Where to store the copy - pu64one = pu64two.
209	*/	209	*/
210	void	210	void
211	u64Copy(U64 * pu64one, const U64 * pu64two)	211	u64Copy(struct counter64 pu64one, const struct counter64 pu64two)
212	{	212	{
213	pu64one = pu64two;	213	pu64one = pu64two;
214	}	214	}
Lines 220-226 u64Copy(U64 * pu64one, const U64 * pu64two) Link Here
220	* @param[in] pu64 Number to be zeroed.	220	* @param[in] pu64 Number to be zeroed.
221	*/	221	*/
222	void	222	void
223	zeroU64(U64 * pu64)	223	zeroU64(struct counter64 *pu64)
224	{	224	{
225	pu64->low = 0;	225	pu64->low = 0;
226	pu64->high = 0;	226	pu64->high = 0;
Lines 232-238 zeroU64(U64 * pu64) Link Here
232	* @param[in] pu64 Number to be checked.	232	* @param[in] pu64 Number to be checked.
233	*/	233	*/
234	int	234	int
235	isZeroU64(const U64 * pu64)	235	isZeroU64(const struct counter64 *pu64)
236	{	236	{
237	return pu64->low == 0 && pu64->high == 0;	237	return pu64->low == 0 && pu64->high == 0;
238	}	238	}
Lines 390-399 netsnmp_c64_check32_and_update(struct counter64 prev_val, struct counter64 new Link Here
390	/** Convert an unsigned 64-bit number to ASCII. */	390	/** Convert an unsigned 64-bit number to ASCII. */
391	void	391	void
392	printU64(char buf, / char [I64CHARSZ+1]; */	392	printU64(char buf, / char [I64CHARSZ+1]; */
393	const U64 * pu64)	393	const struct counter64 *pu64)
394	{	394	{
395	U64 u64a;	395	struct counter64 u64a;
396	U64 u64b;	396	struct counter64 u64b;
397		397
398	char aRes[I64CHARSZ + 1];	398	char aRes[I64CHARSZ + 1];
399	unsigned int u;	399	unsigned int u;
Lines 414-422 printU64(char buf, / char [I64CHARSZ+1]; */ Link Here
414	/** Convert a signed 64-bit number to ASCII. */	414	/** Convert a signed 64-bit number to ASCII. */
415	void	415	void
416	printI64(char buf, / char [I64CHARSZ+1]; */	416	printI64(char buf, / char [I64CHARSZ+1]; */
417	const U64 * pu64)	417	const struct counter64 *pu64)
418	{	418	{
419	U64 u64a;	419	struct counter64 u64a;
420		420
421	if (pu64->high & 0x80000000) {	421	if (pu64->high & 0x80000000) {
422	u64a.high = (uint32_t) ~pu64->high;	422	u64a.high = (uint32_t) ~pu64->high;
Lines 429-439 printI64(char buf, / char [I64CHARSZ+1]; */ Link Here
429	}	429	}
430	}	430	}
431		431
432	/** Convert a signed 64-bit integer from ASCII to U64. */	432	/** Convert a signed 64-bit integer from ASCII to struct counter64. */
433	int	433	int
434	read64(U64 * i64, const char *str)	434	read64(struct counter64 i64, const char str)
435	{	435	{
436	U64 i64p;	436	struct counter64 i64p;
437	unsigned int u;	437	unsigned int u;
438	int sign = 0;	438	int sign = 0;
439	int ok = 0;	439	int ok = 0;

Lines 1-4 Link Here

(-)a/testing/fulltests/unit-tests/T015int64_clib.c (-6 / +5 lines)
1	/* HEADER Testing 64-bit integer operations (U64). */	1	/* HEADER Testing 64-bit integer operations (struct counter64). */
2		2
3	int i, j;	3	int i, j;
4	char buf[22];	4	char buf[22];
Lines 15-21 static const int64_t intval[] = { Link Here
15	};	15	};
16		16
17	for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {	17	for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
18	U64 a, b;	18	struct counter64 a, b;
19	a.low = (uint32_t)intval[i];	19	a.low = (uint32_t)intval[i];
20	a.high = (uint32_t)(intval[i] >> 32);	20	a.high = (uint32_t)(intval[i] >> 32);
21	printI64(buf, &a);	21	printI64(buf, &a);
Lines 27-33 for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) { Link Here
27		27
28	for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {	28	for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
29	for (j = i; j < sizeof(intval)/sizeof(intval[0]); ++j) {	29	for (j = i; j < sizeof(intval)/sizeof(intval[0]); ++j) {
30	U64 a, b;	30	struct counter64 a, b;
31	uint64_t d;	31	uint64_t d;
32	a.low = (uint32_t)intval[i];	32	a.low = (uint32_t)intval[i];
33	a.high = (uint32_t)(intval[i] >> 32);	33	a.high = (uint32_t)(intval[i] >> 32);
Lines 43-49 for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) { Link Here
43		43
44	for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {	44	for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
45	for (j = i; j < sizeof(intval)/sizeof(intval[0]); ++j) {	45	for (j = i; j < sizeof(intval)/sizeof(intval[0]); ++j) {
46	U64 a, b, c;	46	struct counter64 a, b, c;
47	uint64_t d;	47	uint64_t d;
48	a.low = (uint32_t)intval[i];	48	a.low = (uint32_t)intval[i];
49	a.high = (uint32_t)(intval[i] >> 32);	49	a.high = (uint32_t)(intval[i] >> 32);
Lines 58-64 for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) { Link Here
58	}	58	}
59		59
60	{	60	{
61	U64 old_val, new_val;	61	struct counter64 old_val, new_val;
62	old_val.low = 7;	62	old_val.low = 7;
63	old_val.high = 0;	63	old_val.high = 0;
64	new_val = old_val;	64	new_val = old_val;
65	-