ipv6.c

snmp的源代码,已经在我的ubuntu下编译通过

        tcpstatemap[TCPS_CLOSED] = 1;
        tcpstatemap[TCPS_LISTEN] = 2;
        tcpstatemap[TCPS_SYN_SENT] = 3;
        tcpstatemap[TCPS_SYN_RECEIVED] = 4;
        tcpstatemap[TCPS_ESTABLISHED] = 5;
        tcpstatemap[TCPS_CLOSE_WAIT] = 8;
        tcpstatemap[TCPS_FIN_WAIT_1] = 6;
        tcpstatemap[TCPS_CLOSING] = 10;
        tcpstatemap[TCPS_LAST_ACK] = 9;
        tcpstatemap[TCPS_FIN_WAIT_2] = 7;
        tcpstatemap[TCPS_TIME_WAIT] = 11;
        initialized++;
    }
    /* XXX GIGO 0 is an invalid state */
    return (tcpstatemap[0x0f & val]);
}

u_char         *
var_tcp6(register struct variable * vp,
         oid * name,
         size_t * length,
         int exact, size_t * var_len, WriteMethod ** write_method)
{
    oid             newname[MAX_OID_LEN];
    oid             savname[MAX_OID_LEN];
    int             result;
    int             i, j;
    caddr_t         p;
    static struct in6pcb in6pcb, savpcb;
    struct tcpcb    tcpcb;
    int             found, savnameLen;
#if defined(__NetBSD__) && __NetBSD_Version__ >= 106250000	/*1.6Y*/
    struct inpcbtable tcbtable;
    caddr_t	    first;
#elif (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(darwin)
    char           *sysctl_buf;
    struct xinpgen *xig, *oxig;
#else
    static struct in6pcb tcb6;
#endif

    DEBUGMSGTL(("mibII/ipv6", "var_tcp6: "));
    DEBUGMSGOID(("mibII/ipv6", name, *length));
    DEBUGMSG(("mibII/ipv6", " %d\n", exact));

#if defined(__NetBSD__) && __NetBSD_Version__ >= 106250000	/*1.6Y*/
    if (!auto_nlist("tcbtable", (char *) &tcbtable, sizeof(tcbtable)))
        return NULL;
    first = p = (caddr_t)tcbtable.inpt_queue.cqh_first;
#elif !(defined(__FreeBSD__) && __FreeBSD__ >= 3) && !defined(darwin)
    if (!auto_nlist("tcb6", (char *) &tcb6, sizeof(tcb6)))
        return NULL;
    p = (caddr_t) tcb6.in6p_next;
#else
    {
        const char     *tcblist = "net.inet.tcp.pcblist";
        const char     *pp = tcblist;
        size_t          len;

        if (sysctlbyname(tcblist, 0, &len, 0, 0) < 0)
            return NULL;
        if ((sysctl_buf = malloc(len)) == NULL)
            return NULL;
        tcblist = pp;
        if (sysctlbyname(tcblist, sysctl_buf, &len, 0, 0) < 0) {
            free(sysctl_buf);
            return NULL;
        }
        oxig = (struct xinpgen *) sysctl_buf;
        xig = (struct xinpgen *) ((char *) oxig + oxig->xig_len);
        p = (caddr_t) ((char *) xig); /* silence compiler warning */
    }
#endif
    found = savnameLen = 0;
    memcpy((char *) newname, (char *) vp->name,
           (int) vp->namelen * sizeof(oid));
    DEBUGMSGTL(("mibII/ipv6", "start: p=%x\n", p));
    while (
#if defined(__NetBSD__) && __NetBSD_Version__ >= 106250000	/*1.6Y*/
              p && p != first
#elif !(defined(__FreeBSD__) && __FreeBSD__ >= 3) && !defined(darwin)
              p && (u_long) p != auto_nlist_value("tcb6")
#else
              xig->xig_len > sizeof(struct xinpgen)
#endif
        ) {
        DEBUGMSGTL(("mibII/ipv6", "looping: p=%x\n", p));

#if !(defined(__FreeBSD__) && __FreeBSD__ >= 3) && !defined(darwin)
        if (klookup((u_long) p, (char *) &in6pcb, sizeof(in6pcb)) < 0) {
            DEBUGMSGTL(("mibII/ipv6", "klookup fail for tcb6 at %x\n",
                        p));
            found = 0;
            break;
        }
#else
        in6pcb = ((struct xinpcb *) xig)->xi_inp;
#endif
#if defined(__NetBSD__) && __NetBSD_Version__ >= 106250000	/*1.6Y*/
        if (in6pcb.in6p_af != AF_INET6)
            goto skip;
#elif (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(darwin)
        if (0 == (in6pcb.inp_vflag & INP_IPV6))
            goto skip;
#endif
        if (klookup
            ((u_long) in6pcb.in6p_ppcb, (char *) &tcpcb, sizeof(tcpcb))
            < 0) {
            DEBUGMSGTL(("mibII/ipv6", "klookup fail for tcb6.tcpcb at %x\n",
                        in6pcb.in6p_ppcb));
            found = 0;
            break;
        }
        j = (int) vp->namelen;
        for (i = 0; i < sizeof(struct in6_addr); i++)
            newname[j++] = in6pcb.in6p_laddr.s6_addr[i];
        newname[j++] = ntohs(in6pcb.in6p_lport);
        for (i = 0; i < sizeof(struct in6_addr); i++)
            newname[j++] = in6pcb.in6p_faddr.s6_addr[i];
        newname[j++] = ntohs(in6pcb.in6p_fport);
        if (IN6_IS_ADDR_LINKLOCAL(&in6pcb.in6p_laddr))
            newname[j++] =
                ntohs(*(uint16_t *) & in6pcb.in6p_laddr.s6_addr[2]);
        else
            newname[j++] = 0;
        /*XXX*/ newname[j++] = mapTcpState((int)tcpcb.t_state);

        DEBUGMSGTL(("mibII/ipv6", "var_tcp6 new: %d %d ",
                        (int) vp->namelen, j));
        DEBUGMSGOID(("mibII/ipv6", newname, j));
        DEBUGMSG(("mibII/ipv6", " %d\n", exact));

#if 1                           /* this is very odd but sometimes happen, and cause infinite loop */
        if (ntohs(in6pcb.in6p_lport) == 0)
            goto skip;
#endif
        result = snmp_oid_compare(name, *length, newname, j);
        if (exact && (result == 0)) {
                memcpy(&savpcb, &in6pcb, sizeof(savpcb));
                savnameLen = j;
                memcpy(savname, newname, j * sizeof(oid));
                found++;
                break;
        } else if (!exact && (result < 0)) {
            /*
             *  take the least greater one
             */
            if ((savnameLen == 0) ||
              (snmp_oid_compare(savname, savnameLen, newname, j) > 0)) {
                memcpy(&savpcb, &in6pcb, sizeof(savpcb));
                savnameLen = j;
                memcpy(savname, newname, j * sizeof(oid));
                    found++;
            }
        }

      skip:
#if defined(__NetBSD__) && __NetBSD_Version__ >= 106250000	/*1.6Y*/
        p = (caddr_t)in6pcb.in6p_queue.cqe_next;
#elif !(defined(__FreeBSD__) && __FreeBSD__ >= 3) && !defined(darwin)
        p = (caddr_t) in6pcb.in6p_next;
#else
        xig = (struct xinpgen *) ((char *) xig + xig->xig_len);
#endif
    }
#if (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(darwin)
    free(sysctl_buf);
#endif
    DEBUGMSGTL(("mibII/ipv6", "found=%d\n", found));
    if (!found)
        return NULL;
    *length = savnameLen;
    memcpy((char *) name, (char *) savname, *length * sizeof(oid));
    memcpy(&in6pcb, &savpcb, sizeof(savpcb));
    *write_method = 0;
    *var_len = sizeof(long);    /* default to 'long' results */

/*
    DEBUGMSGTL(("mibII/ipv6", "var_tcp6 found: "));
    DEBUGMSGOID(("mibII/ipv6", name, *length));
    DEBUGMSG(("mibII/ipv6", " %d\n", exact));
*/
    DEBUGMSGTL(("mibII/ipv6", "magic=%d\n", vp->magic));
    switch (vp->magic) {
    case IPV6TCPLOCALADDR:
        *var_len = sizeof(struct in6_addr);
        return (u_char *) & in6pcb.in6p_laddr.s6_addr[0];
    case IPV6TCPLOCALPORT:
        long_return = ntohs(in6pcb.in6p_lport);
        return (u_char *) & long_return;
    case IPV6TCPREMOTEADDR:
        *var_len = sizeof(struct in6_addr);
        return (u_char *) & in6pcb.in6p_faddr.s6_addr[0];
    case IPV6TCPREMOTEPORT:
        long_return = ntohs(in6pcb.in6p_fport);
        return (u_char *) & long_return;
    case IPV6TCPIFINDEX:
        if (IN6_IS_ADDR_LINKLOCAL(&in6pcb.in6p_laddr))
            long_return =
                ntohs(*(uint16_t *) & in6pcb.in6p_laddr.s6_addr[2]);
        else
            long_return = 0;
        /*XXX*/ return (u_char *) & long_return;
    case IPV6TCPCONNSTATE:
        long_return = mapTcpState((int)tcpcb.t_state);
        return (u_char *) & long_return;
    default:
        break;
    }
    ERROR_MSG("");
    return NULL;
}

#endif                          /*TCP6 */

#else                           /* !linux / linux */

/*
 * Linux dependent part 
 */
static unsigned long
linux_read_ip6_stat_ulong(const char *file)
{
    FILE           *f;
    unsigned long   value;
    f = fopen(file, "r");
    if (!f)
        return 0;
    if (fscanf(f, "%lu", &value) != 1) {
        fclose(f);
        return 0;
    }
    fclose(f);
    return value;
}

void
linux_read_ip6_stat(struct ip6_mib *ip6stat)
{
    if (!ip6stat)
        return;
    memset(ip6stat, 0, sizeof(*ip6stat));
    ip6stat->Ipv6Forwarding =
        linux_read_ip6_stat_ulong
        ("/proc/sys/net/ipv6/conf/all/forwarding");
    ip6stat->Ipv6DefaultHopLimit =
        linux_read_ip6_stat_ulong
        ("/proc/sys/net/ipv6/conf/default/hop_limit");
}

u_char         *
var_ipv6(register struct variable *vp,
         oid * name,
         size_t * length,
         int exact, size_t * var_len, WriteMethod ** write_method)
{
    static struct ip6_mib ip6stat;

    if (header_ipv6(vp, name, length, exact, var_len, write_method)
        == MATCH_FAILED) {
        return NULL;
    }
    linux_read_ip6_stat(&ip6stat);

    switch (vp->magic) {
    case IPV6DEFAULTHOPLIMIT:
        return (u_char *) & ip6stat.Ipv6DefaultHopLimit;
    case IPV6FORWARDING:
        long_return = (ip6stat.Ipv6Forwarding) ? 1 : 2;
        return (u_char *) & long_return;
    case IPV6INTERFACES:
#ifdef HAVE_IF_NAMEINDEX
        long_return = if_countifindex();
        if (long_return < 0)
            break;
        return (u_char *) & long_return;
#endif
        break;
    default:
        DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_ipv6\n",
                    vp->magic));
    }
    return NULL;
}

u_char         *
var_ifv6Entry(register struct variable * vp,
              oid * name,
              size_t * length,
              int exact, size_t * var_len, WriteMethod ** write_method)
{
#ifndef HAVE_IF_NAMEINDEX
    return NULL;
#else
    int             interface;
    int             max;
    char           *p;
    struct ifreq    ifr;
    int             s;

    max = if_maxifindex();
    if (max < 0)
        return NULL;

    if (header_ipv6_scan
        (vp, name, length, exact, var_len, write_method, 1, max)
        == MATCH_FAILED) {
        return NULL;
    }
    interface = name[*length - 1];
    DEBUGMSGTL(("mibII/ipv6", "interface: %d(%s)\n",
                interface, if_getname(interface)));
    if (interface > max)
        return NULL;

    switch (vp->magic) {
    case IPV6IFDESCR:
        p = if_getname(interface);
        if (p) {
            *var_len = strlen(p);
            return p;
        }
        break;
    case IPV6IFLOWLAYER:
        /*
         * should check if type, this is a hard one... 
         */
        *var_len = nullOidLen;
        return (u_char *) nullOid;
    case IPV6IFEFFECTMTU:
        {
            p = if_getname(interface);
            if (!p)
                break;
            memset(&ifr, 0, sizeof(ifr));
            ifr.ifr_addr.sa_family = AF_INET6;
            strncpy(ifr.ifr_name, p, sizeof(ifr.ifr_name));
            if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0)
                break;
            if (ioctl(s, SIOCGIFMTU, (caddr_t) & ifr) < 0) {
                close(s);
                break;
            }
            long_return = ifr.ifr_mtu;
            close(s);
            return (u_char *) & long_return;
        }
    case IPV6IFPHYSADDRESS:
        {
            static struct ifreq buf;
            int             ok = 0;
            p = if_getname(interface);
            if (!p)
                break;
            memset(&ifr, 0, sizeof(ifr));
            ifr.ifr_addr.sa_family = AF_INET6;
            strncpy(ifr.ifr_name, p, sizeof(ifr.ifr_name));
            if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0)
                break;
            if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
                memset(buf.ifr_hwaddr.sa_data, 0,
                       sizeof(buf.ifr_hwaddr.sa_data));
                *var_len = 0;
            } else {
                memcpy(buf.ifr_hwaddr.sa_data, ifr.ifr_hwaddr.sa_data, 6);
                *var_len = (buf.ifr_hwaddr.sa_data[0] |
                            buf.ifr_hwaddr.sa_data[1] |
                            buf.ifr_hwaddr.sa_data[2] |
                            buf.ifr_hwaddr.sa_data[3] |
                            buf.ifr_hwaddr.sa_data[4] |
                            buf.ifr_hwaddr.sa_data[5]) ? 6 : 0;
                ok = 1;
            }
            close(s);
            return (ok ? ((u_char *) & buf.ifr_hwaddr.sa_data) : NULL);
        }
    case IPV6IFADMSTATUS:
    case IPV6IFOPERSTATUS:
        {
            int             flag = 0;
            p = if_getname(interface);
            if (!p)
                break;
            memset(&ifr, 0, sizeof(ifr));
            ifr.ifr_addr.sa_family = AF_INET6;
            strncpy(ifr.ifr_name, p, sizeof(ifr.ifr_name));
            if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0)
                break;
            if (ioctl(s, SIOCGIFFLAGS, &ifr) < 0) {
                close(s);
                break;
            }
            close(s);
            switch (vp->magic) {
            case IPV6IFADMSTATUS:
                flag = IFF_RUNNING;
                break;
            case IPV6IFOPERSTATUS: