← Back to branch summary

~ubuntu-branches/ubuntu/precise/net-snmp/precise

« back to all changes in this revision

Viewing changes to agent/mibgroup/mibII/var_route.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2009-11-26 01:27:00 UTC
  • mfrom: (1.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20091126012700-pox7w0a5j2x305h9
Tags: 5.4.2.1~dfsg-3ubuntu1
https://launchpad.net/bugs/104738
https://launchpad.net/bugs/254261
https://launchpad.net/bugs/250459
https://launchpad.net/bugs/426813
* Merge from debian testing.  Remaining changes:
  - Set Ubuntu maintainer address.
  - net-snmp-config: Use bash. (LP: #104738)
  - Removed multiuser option when calling update-rc.d. (LP: #254261)
  - debian/snmpd.init: LSBify the init script.
  - debian/patches/52_fix_snmpcmd_1_typo.patch: Adjust a typo in snmpcmd.1
    (LP: #250459)
  - debian/patches/99-fix-ubuntu-div0.patch: Fix dvision by zero.
    (LP: #426813).
 * Dropped patches:
   - debian/patches/101-fix-ipalias.patch: Applied upstream.
   - debian/patches/99-fix-net-snmp-syslog.patch: Applied upstream.
   - debian/patches/99-fix-perl-counter-in-subagent.patch: Applied upstream.
   - ebian/patches/103-fix-ubuntu-lmsensors.patch: No longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
agent/mibgroup/mibII/var_route.c
115
115
    u_char         *cp;
116
116
    u_char         *ap;
117
117
    oid            *op;
 
118
    static in_addr_t addr_ret;
118
119
 
119
120
    *write_method = NULL;  /* write_rte;  XXX:  SET support not really implemented */
120
121
 
227
228
 
228
229
    switch (vp->magic) {
229
230
    case IPROUTEDEST:
230
 
        *var_len = sizeof(uint32_t);
 
231
        *var_len = sizeof(addr_ret);
231
232
        return (u_char *) get_in_address((struct sockaddr *) (rtp + 1),
232
233
                                         rtp->rtm_addrs, RTA_DST);
233
234
    case IPROUTEIFINDEX:
261
262
        long_return = -1;
262
263
        return (u_char *) & long_return;
263
264
    case IPROUTENEXTHOP:
264
 
        *var_len = sizeof(uint32_t);
265
 
        return (u_char *) get_in_address((struct sockaddr *) (rtp + 1),
 
265
        *var_len = sizeof(addr_ret);
 
266
        return (u_char *) get_in_address((struct sockaddr *) (rtp + 1),
266
267
                                         rtp->rtm_addrs, RTA_GATEWAY);
267
268
    case IPROUTETYPE:
268
269
        if (rtp->rtm_flags & RTF_UP) {
287
288
        long_return = 0;
288
289
        return (u_char *) & long_return;
289
290
    case IPROUTEMASK:
 
291
        *var_len = sizeof(addr_ret);         
290
292
        if (rtp->rtm_flags & RTF_HOST) {
291
 
            long_return = 0x00000001;
292
 
            return (u_char *) & long_return;
 
293
            addr_ret = 0x00000001;
 
294
            return (u_char *) & addr_ret;
293
295
        } else {
294
296
            return (u_char *) get_in_address((struct sockaddr *) (rtp + 1),
295
297
                                             rtp->rtm_addrs, RTA_NETMASK);
434
436
    static oid      saveName[MAX_OID_LEN], Current[MAX_OID_LEN];
435
437
    u_char         *cp;
436
438
    oid            *op;
 
439
    static in_addr_t addr_ret;
437
440
#if NEED_KLGETSA
438
441
    struct sockaddr_in *sa;
439
442
#endif
538
541
 
539
542
    switch (vp->magic) {
540
543
    case IPROUTEDEST:
541
 
        *var_len = sizeof(uint32_t);
 
544
        *var_len = sizeof(addr_ret);
542
545
#if NEED_KLGETSA
543
546
        sa = klgetsa((struct sockaddr_in *) rthead[RtIndex]->rt_dst);
544
547
        return (u_char *) & (sa->sin_addr.s_addr);
545
548
#elif defined(hpux11)
546
 
        long_return = rt[RtIndex].Dest;
547
 
        return (u_char *) & long_return;
 
549
        addr_ret = rt[RtIndex].Dest;
 
550
        return (u_char *) & addr_ret;
548
551
#else
549
552
        return (u_char *) & ((struct sockaddr_in *) &rthead[RtIndex]->
550
553
                             rt_dst)->sin_addr.s_addr;
597
600
        long_return = -1;
598
601
        return (u_char *) & long_return;
599
602
    case IPROUTENEXTHOP:
600
 
        *var_len = sizeof(uint32_t);
 
603
        *var_len = sizeof(addr_ret);
601
604
#if NEED_KLGETSA
602
605
        sa = klgetsa((struct sockaddr_in *) rthead[RtIndex]->rt_gateway);
603
606
        return (u_char *) & (sa->sin_addr.s_addr);
604
607
#elif defined(hpux11)
605
 
        long_return = rt[RtIndex].NextHop;
606
 
        return (u_char *) & long_return;
 
608
        addr_ret = rt[RtIndex].NextHop;
 
609
        return (u_char *) & addr_ret;
607
610
#else
608
611
        return (u_char *) & ((struct sockaddr_in *) &rthead[RtIndex]->
609
612
                             rt_gateway)->sin_addr.s_addr;
640
643
        long_return = 0;
641
644
        return (u_char *) & long_return;
642
645
    case IPROUTEMASK:
643
 
        *var_len = 4;
 
646
        *var_len = sizeof(addr_ret);
644
647
#if NEED_KLGETSA
645
648
        /*
646
649
         * XXX - Almost certainly not right
649
652
#if NETSNMP_NO_DUMMY_VALUES
650
653
        return NULL;
651
654
#endif
652
 
        long_return = 0;
 
655
        addr_ret = 0;
653
656
#elif defined(hpux11)
654
 
        long_return = rt[RtIndex].Mask;
655
 
        return (u_char *) & long_return;
 
657
        addr_ret = rt[RtIndex].Mask;
 
658
        return (u_char *) & addr_ret;
656
659
#else                           /* !NEED_KLGETSA && !hpux11 */
657
660
        if (((struct sockaddr_in *) &rthead[RtIndex]->rt_dst)->sin_addr.
658
661
            s_addr == 0)
659
 
            long_return = 0;    /* Default route */
 
662
            addr_ret = 0;    /* Default route */
660
663
        else {
661
664
#ifndef linux
662
665
            if (!NETSNMP_KLOOKUP(rthead[RtIndex]->rt_ifp,
670
673
                return NULL;
671
674
            }
672
675
 
673
 
            long_return = rt_ifnetaddr.ia_subnetmask;
 
676
            addr_ret = rt_ifnetaddr.ia_subnetmask;
674
677
#else                           /* linux */
675
678
            cp = (u_char *) &
676
679
                (((struct sockaddr_in *) &(rthead[RtIndex]->rt_dst))->
681
684
#endif                          /* linux */
682
685
        }
683
686
#endif                          /* NEED_KLGETSA */
684
 
        return (u_char *) & long_return;
 
687
        return (u_char *) & addr_ret;
685
688
    case IPROUTEINFO:
686
689
        *var_len = nullOidLen;
687
690
        return (u_char *) nullOid;
738
741
    mib2_ipRouteEntry_t Lowentry, Nextentry, entry;
739
742
    int             Found = 0;
740
743
    req_e           req_type;
741
 
    static uint32_t ipaddr_return;
 
744
    static in_addr_t addr_ret;
742
745
 
743
746
    *write_method = NULL;  /* write_rte;  XXX:  SET support not really implemented */
744
747
 
803
806
 
804
807
    switch (vp->magic) {
805
808
    case IPROUTEDEST:
806
 
        *var_len = sizeof(uint32_t);
807
 
        ipaddr_return = Lowentry.ipRouteDest;
808
 
        return (u_char *) & ipaddr_return;
 
809
        *var_len = sizeof(addr_ret);
 
810
        addr_ret = Lowentry.ipRouteDest;
 
811
        return (u_char *) & addr_ret;
809
812
    case IPROUTEIFINDEX:
810
813
#ifdef NETSNMP_INCLUDE_IFTABLE_REWRITES
811
814
        Lowentry.ipRouteIfIndex.o_bytes[Lowentry.ipRouteIfIndex.o_length] = '\0';
831
834
        long_return = Lowentry.ipRouteMetric4;
832
835
        return (u_char *) & long_return;
833
836
    case IPROUTENEXTHOP:
834
 
        *var_len = sizeof(uint32_t);
835
 
        ipaddr_return = Lowentry.ipRouteNextHop;
836
 
        return (u_char *) & ipaddr_return;
 
837
        *var_len = sizeof(addr_ret);
 
838
        addr_ret = Lowentry.ipRouteNextHop;
 
839
        return (u_char *) & addr_ret;
837
840
    case IPROUTETYPE:
838
841
        long_return = Lowentry.ipRouteType;
839
842
        return (u_char *) & long_return;
846
849
        long_return = Lowentry.ipRouteAge;
847
850
        return (u_char *) & long_return;
848
851
    case IPROUTEMASK:
849
 
        *var_len = sizeof(uint32_t);
850
 
        ipaddr_return = Lowentry.ipRouteMask;
851
 
        return (u_char *) & ipaddr_return;
 
852
        *var_len = sizeof(addr_ret);
 
853
        addr_ret = Lowentry.ipRouteMask;
 
854
        return (u_char *) & addr_ret;
852
855
    default:
853
856
        DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_ipRouteEntry\n",
854
857
                    vp->magic));
862
865
static int      qsort_compare(const void *, const void *);
863
866
#endif
864
867
 
865
 
#if defined(RTENTRY_4_4) || defined(RTENTRY_RT_NEXT)
 
868
#if defined(RTENTRY_4_4) || defined(RTENTRY_RT_NEXT) || defined(hpux11)
866
869
 
867
870
#if defined(RTENTRY_4_4) && !defined(hpux11)
868
871
void
1477
1480
    static long     Time_Of_Last_Reload = 0;
1478
1481
    u_char          dest_addr[4];
1479
1482
    MIB_IPFORWARDROW temp_row;
 
1483
    static in_addr_t addr_ret;
1480
1484
 
1481
1485
 
1482
1486
    /** 
1608
1612
 
1609
1613
    switch (vp->magic) {
1610
1614
    case IPROUTEDEST:
1611
 
        *var_len = sizeof(uint32_t);
 
1615
        *var_len = sizeof(addr_ret);
1612
1616
        *write_method = write_rte;
1613
 
        long_return = pIpRtrTable->table[RtIndex].dwForwardDest;
1614
 
        return (u_char *) & long_return;
 
1617
        addr_ret = pIpRtrTable->table[RtIndex].dwForwardDest;
 
1618
        return (u_char *) & addr_ret;
1615
1619
    case IPROUTEIFINDEX:
1616
1620
        *write_method = write_rte;
1617
1621
        long_return = pIpRtrTable->table[RtIndex].dwForwardIfIndex;
1637
1641
        long_return = pIpRtrTable->table[RtIndex].dwForwardMetric5;
1638
1642
        return (u_char *) & long_return;
1639
1643
    case IPROUTENEXTHOP:
1640
 
        *var_len = sizeof(uint32_t);
 
1644
        *var_len = sizeof(addr_ret);
1641
1645
        *write_method = write_rte;
1642
 
        long_return = pIpRtrTable->table[RtIndex].dwForwardNextHop;
1643
 
        return (u_char *) & long_return;
 
1646
        addr_ret = pIpRtrTable->table[RtIndex].dwForwardNextHop;
 
1647
        return (u_char *) & addr_ret;
1644
1648
    case IPROUTETYPE:
1645
1649
        *write_method = write_rte;
1646
1650
        long_return = pIpRtrTable->table[RtIndex].dwForwardType;
1654
1658
        return (u_char *) & long_return;
1655
1659
    case IPROUTEMASK:
1656
1660
        *write_method = write_rte;
1657
 
        long_return = pIpRtrTable->table[RtIndex].dwForwardMask;
1658
 
        return (u_char *) & long_return;
 
1661
        *var_len = sizeof(addr_ret);
 
1662
        addr_ret = pIpRtrTable->table[RtIndex].dwForwardMask;
 
1663
        return (u_char *) & addr_ret;
1659
1664
    case IPROUTEINFO:
1660
1665
        *var_len = nullOidLen;
1661
1666
        return (u_char *) nullOid;
1829
1834
    static struct snmprt *savert;
1830
1835
    static int      saveNameLen, saveExact;
1831
1836
    static oid      saveName[14], Current[14];
1832
 
 
 
1837
    static in_addr_t addr_ret;
 
1838
    
1833
1839
    *write_method = NULL;  /* write_rte;  XXX:  SET support not really implemented */
1834
1840
 
1835
1841
#if 0
1905
1911
 
1906
1912
    switch (vp->magic) {
1907
1913
    case IPROUTEDEST:
1908
 
        *var_len = sizeof(uint32_t);
1909
 
        long_return = rt->dest.s_addr;
1910
 
        return (u_char *) & long_return;
 
1914
        addr_ret = rt->dest.s_addr;
 
1915
        *var_len = sizeof(addr_ret);
 
1916
        return (u_char *) & addr_ret;
1911
1917
 
1912
1918
    case IPROUTEIFINDEX:
1913
1919
        long_return = rt->index;
1930
1936
        return (u_char *) & long_return;
1931
1937
 
1932
1938
    case IPROUTENEXTHOP:
1933
 
        *var_len = sizeof(uint32_t);
 
1939
        *var_len = sizeof(addr_ret);
1934
1940
        if (rt->gateway.s_addr == 0 && rt->ifa.s_addr == 0)
1935
 
            long_return = 0;
 
1941
            addr_ret = 0;
1936
1942
        else if (rt->gateway.s_addr == 0)
1937
 
            long_return = rt->ifa.s_addr;
 
1943
            addr_ret = rt->ifa.s_addr;
1938
1944
        else
1939
 
            long_return = rt->gateway.s_addr;
1940
 
        return (u_char *) & long_return;
 
1945
            addr_ret = rt->gateway.s_addr;
 
1946
        return (u_char *) & addr_ret;
1941
1947
 
1942
1948
    case IPROUTETYPE:
1943
1949
        if (rt->hdr->rtm_flags & RTF_UP) {
1963
1969
        return (u_char *) & long_return;
1964
1970
 
1965
1971
    case IPROUTEMASK:
1966
 
        long_return = rt->netmask.s_addr;
1967
 
        return (u_char *) & long_return;
 
1972
        addr_ret = rt->netmask.s_addr;
 
1973
        *var_len = sizeof(addr_ret);
 
1974
        return (u_char *) & addr_ret;
1968
1975
 
1969
1976
    case IPROUTEINFO:
1970
1977
        *var_len = nullOidLen;