Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/sys/netinet6/ip6_input.c,v rcsdiff: /ftp/cvs/cvsroot/src/sys/netinet6/ip6_input.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.39 retrieving revision 1.71 diff -u -p -r1.39 -r1.71 --- src/sys/netinet6/ip6_input.c 2001/03/21 19:12:56 1.39 +++ src/sys/netinet6/ip6_input.c 2004/02/11 10:47:28 1.71 @@ -1,5 +1,5 @@ -/* $NetBSD: ip6_input.c,v 1.39 2001/03/21 19:12:56 itojun Exp $ */ -/* $KAME: ip6_input.c,v 1.183 2001/03/01 15:15:23 itojun Exp $ */ +/* $NetBSD: ip6_input.c,v 1.71 2004/02/11 10:47:28 itojun Exp $ */ +/* $KAME: ip6_input.c,v 1.188 2001/03/29 05:34:31 itojun Exp $ */ /* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. @@ -42,11 +42,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors + * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * @@ -65,6 +61,9 @@ * @(#)ip_input.c 8.2 (Berkeley) 1/4/94 */ +#include +__KERNEL_RCSID(0, "$NetBSD: ip6_input.c,v 1.71 2004/02/11 10:47:28 itojun Exp $"); + #include "opt_inet.h" #include "opt_ipsec.h" #include "opt_pfil_hooks.h" @@ -82,6 +81,7 @@ #include #include #include +#include #include #include @@ -97,7 +97,7 @@ #ifdef INET #include #include -#endif /*INET*/ +#endif /* INET */ #include #include #include @@ -105,7 +105,6 @@ #include #include #include -#include #ifdef IPSEC #include @@ -116,10 +115,13 @@ /* we need it for NLOOP. */ #include "loop.h" #include "faith.h" - #include "gif.h" #include "bpfilter.h" +#if NGIF > 0 +#include +#endif + #include extern struct domain inet6domain; @@ -143,6 +145,7 @@ struct ip6stat ip6stat; static void ip6_init2 __P((void *)); static int ip6_hopopts_input __P((u_int32_t *, u_int32_t *, struct mbuf **, int *)); +static struct mbuf *ip6_pullexthdr __P((struct mbuf *, size_t, int)); /* * IP6 initialization: fill in IP6 protocol switch table. @@ -153,7 +156,6 @@ ip6_init() { struct ip6protosw *pr; int i; - struct timeval tv; pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW); if (pr == 0) @@ -168,12 +170,6 @@ ip6_init() ip6intrq.ifq_maxlen = ip6qmaxlen; nd6_init(); frag6_init(); - /* - * in many cases, random() here does NOT return random number - * as initialization during bootstrap time occur in fixed order. - */ - microtime(&tv); - ip6_flow_seq = random() ^ tv.tv_usec; ip6_init2((void *)0); @@ -192,18 +188,10 @@ static void ip6_init2(dummy) void *dummy; { - /* - * to route local address of p2p link to loopback, - * assign loopback address first. - */ - in6_ifattach(&loif[0], NULL); /* nd6_timer_init */ callout_init(&nd6_timer_ch); callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL); - /* router renumbering prefix list maintenance */ - callout_init(&in6_rr_timer_ch); - callout_reset(&in6_rr_timer_ch, hz, in6_rr_timer, NULL); } /* @@ -216,7 +204,7 @@ ip6intr() struct mbuf *m; for (;;) { - s = splimp(); + s = splnet(); IF_DEQUEUE(&ip6intrq, m); splx(s); if (m == 0) @@ -237,20 +225,19 @@ ip6_input(m) u_int32_t rtalert = ~0; int nxt, ours = 0; struct ifnet *deliverifp = NULL; + int srcrt = 0; #ifdef IPSEC /* * should the inner packet be considered authentic? * see comment in ah4_input(). */ - if (m) { - m->m_flags &= ~M_AUTHIPHDR; - m->m_flags &= ~M_AUTHIPDGM; - } + m->m_flags &= ~M_AUTHIPHDR; + m->m_flags &= ~M_AUTHIPDGM; #endif /* - * mbuf statistics by kazu + * mbuf statistics */ if (m->m_flags & M_EXT) { if (m->m_next) @@ -258,29 +245,40 @@ ip6_input(m) else ip6stat.ip6s_mext1++; } else { +#define M2MMAX (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0])) if (m->m_next) { if (m->m_flags & M_LOOP) { - ip6stat.ip6s_m2m[loif[0].if_index]++; /*XXX*/ - } else if (m->m_pkthdr.rcvif->if_index <= 31) + ip6stat.ip6s_m2m[loif[0].if_index]++; /* XXX */ + } else if (m->m_pkthdr.rcvif->if_index < M2MMAX) ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++; else ip6stat.ip6s_m2m[0]++; } else ip6stat.ip6s_m1++; +#undef M2MMAX } in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_receive); ip6stat.ip6s_total++; -#ifndef PULLDOWN_TEST - /* XXX is the line really necessary? */ - IP6_EXTHDR_CHECK(m, 0, sizeof(struct ip6_hdr), /*nothing*/); -#endif - - if (m->m_len < sizeof(struct ip6_hdr)) { - struct ifnet *inifp; - inifp = m->m_pkthdr.rcvif; - if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == 0) { + /* + * If the IPv6 header is not aligned, slurp it up into a new + * mbuf with space for link headers, in the event we forward + * it. OTherwise, if it is aligned, make sure the entire base + * IPv6 header is in the first mbuf of the chain. + */ + if (IP6_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0) { + struct ifnet *inifp = m->m_pkthdr.rcvif; + if ((m = m_copyup(m, sizeof(struct ip6_hdr), + (max_linkhdr + 3) & ~3)) == NULL) { + /* XXXJRT new stat, please */ + ip6stat.ip6s_toosmall++; + in6_ifstat_inc(inifp, ifs6_in_hdrerr); + return; + } + } else if (__predict_false(m->m_len < sizeof(struct ip6_hdr))) { + struct ifnet *inifp = m->m_pkthdr.rcvif; + if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == NULL) { ip6stat.ip6s_toosmall++; in6_ifstat_inc(inifp, ifs6_in_hdrerr); return; @@ -308,25 +306,27 @@ ip6_input(m) * not the decapsulated packet. */ #ifdef IPSEC - if (!ipsec_gethist(m, NULL)) + if (!ipsec_getnhist(m)) #else if (1) #endif { + struct in6_addr odst; + + odst = ip6->ip6_dst; if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.rcvif, PFIL_IN) != 0) return; if (m == NULL) return; ip6 = mtod(m, struct ip6_hdr *); + srcrt = !IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst); } #endif /* PFIL_HOOKS */ - ip6stat.ip6s_nxthist[ip6->ip6_nxt]++; #ifdef ALTQ - /* XXX Temporary until ALTQ is changed to use a pfil hook */ if (altq_input != NULL && (*altq_input)(m, AF_INET6) == 0) { /* packet is dropped by traffic conditioner */ return; @@ -334,25 +334,28 @@ ip6_input(m) #endif /* - * Scope check + * Check against address spoofing/corruption. */ if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src) || IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_dst)) { + /* + * XXX: "badscope" is not very suitable for a multicast source. + */ ip6stat.ip6s_badscope++; in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr); goto bad; } /* - * The following check is not documented in the spec. Malicious party - * may be able to use IPv4 mapped addr to confuse tcp/udp stack and - * bypass security checks (act as if it was from 127.0.0.1 by using - * IPv6 src ::ffff:127.0.0.1). Be cautious. + * The following check is not documented in specs. A malicious + * party may be able to use IPv4 mapped addr to confuse tcp/udp stack + * and bypass security checks (act as if it was from 127.0.0.1 by using + * IPv6 src ::ffff:127.0.0.1). Be cautious. * - * This check chokes if we are in SIIT cloud. As none of BSDs support - * IPv4-less kernel compilation, we cannot support SIIT environment - * at all. So, it makes more sense for us to reject any malicious - * packets for non-SIIT environment, than try to do a partical support - * for SIIT environment. + * This check chokes if we are in an SIIT cloud. As none of BSDs + * support IPv4-less kernel compilation, we cannot support SIIT + * environment at all. So, it makes more sense for us to reject any + * malicious packets for non-SIIT environment, than try to do a + * partial support for SIIT environment. */ if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) || IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) { @@ -402,33 +405,35 @@ ip6_input(m) goto bad; } } - -#ifndef FAKE_LOOPBACK_IF - if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) -#else - if (1) -#endif - { - if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) - ip6->ip6_src.s6_addr16[1] - = htons(m->m_pkthdr.rcvif->if_index); - if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst)) - ip6->ip6_dst.s6_addr16[1] - = htons(m->m_pkthdr.rcvif->if_index); - } - /* - * XXX we need this since we do not have "goto ours" hack route - * for some of our ifaddrs on loopback interface. - * we should correct it by changing in6_ifattach to install - * "goto ours" hack route. - */ - if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) != 0) { - if (IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_dst)) { - ours = 1; - deliverifp = m->m_pkthdr.rcvif; - goto hbhcheck; + if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) + ip6->ip6_src.s6_addr16[1] + = htons(m->m_pkthdr.rcvif->if_index); + if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst)) + ip6->ip6_dst.s6_addr16[1] + = htons(m->m_pkthdr.rcvif->if_index); + + /* + * We use rt->rt_ifp to determine if the address is ours or not. + * If rt_ifp is lo0, the address is ours. + * The problem here is, rt->rt_ifp for fe80::%lo0/64 is set to lo0, + * so any address under fe80::%lo0/64 will be mistakenly considered + * local. The special case is supplied to handle the case properly + * by actually looking at interface addresses + * (using in6ifa_ifpwithaddr). + */ + if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) != 0 && + IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_dst)) { + if (!in6ifa_ifpwithaddr(m->m_pkthdr.rcvif, &ip6->ip6_dst)) { + icmp6_error(m, ICMP6_DST_UNREACH, + ICMP6_DST_UNREACH_ADDR, 0); + /* m is already freed */ + return; } + + ours = 1; + deliverifp = m->m_pkthdr.rcvif; + goto hbhcheck; } /* @@ -459,7 +464,7 @@ ip6_input(m) * Unicast check */ if (ip6_forward_rt.ro_rt != NULL && - (ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 && + (ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 && IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, &((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr)) ip6stat.ip6s_forward_cachehit++; @@ -496,6 +501,7 @@ ip6_input(m) if (ip6_forward_rt.ro_rt && (ip6_forward_rt.ro_rt->rt_flags & (RTF_HOST|RTF_GATEWAY)) == RTF_HOST && + !(ip6_forward_rt.ro_rt->rt_flags & RTF_CLONED) && #if 0 /* * The check below is redundant since the comparison of @@ -503,7 +509,7 @@ ip6_input(m) * already done through looking up the routing table. */ IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, - &rt6_key(ip6_forward_rt.ro_rt)->sin6_addr) && + &rt6_key(ip6_forward_rt.ro_rt)->sin6_addr) && #endif ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_LOOP) { struct in6_ifaddr *ia6 = @@ -531,15 +537,15 @@ ip6_input(m) } /* - * FAITH(Firewall Aided Internet Translator) + * FAITH (Firewall Aided Internet Translator) */ #if defined(NFAITH) && 0 < NFAITH if (ip6_keepfaith) { - if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp - && ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) { + if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp && + ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) { /* XXX do we need more sanity checks? */ ours = 1; - deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /*faith*/ + deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */ goto hbhcheck; } } @@ -600,7 +606,7 @@ ip6_input(m) ip6 = mtod(m, struct ip6_hdr *); /* - * if the payload length field is 0 and the next header field + * if the payload length field is 0 and the next header field * indicates Hop-by-Hop Options header, then a Jumbo Payload * option MUST be included. */ @@ -608,7 +614,7 @@ ip6_input(m) /* * Note that if a valid jumbo payload option is * contained, ip6_hoptops_input() must set a valid - * (non-zero) payload length to the variable plen. + * (non-zero) payload length to the variable plen. */ ip6stat.ip6s_badoptions++; in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard); @@ -618,17 +624,13 @@ ip6_input(m) (caddr_t)&ip6->ip6_plen - (caddr_t)ip6); return; } -#ifndef PULLDOWN_TEST - /* ip6_hopopts_input() ensures that mbuf is contiguous */ - hbh = (struct ip6_hbh *)(ip6 + 1); -#else IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr), sizeof(struct ip6_hbh)); if (hbh == NULL) { ip6stat.ip6s_tooshort++; return; } -#endif + KASSERT(IP6_HDR_ALIGNED_P(hbh)); nxt = hbh->ip6h_nxt; /* @@ -681,9 +683,9 @@ ip6_input(m) return; } } else if (!ours) { - ip6_forward(m, 0); + ip6_forward(m, srcrt); return; - } + } ip6 = mtod(m, struct ip6_hdr *); @@ -717,6 +719,7 @@ ip6_input(m) ip6stat.ip6s_delivered++; in6_ifstat_inc(deliverifp, ifs6_in_deliver); nest = 0; + while (nxt != IPPROTO_DONE) { if (ip6_hdrnestlimit && (++nest > ip6_hdrnestlimit)) { ip6stat.ip6s_toomanyhdr++; @@ -745,7 +748,7 @@ ip6_input(m) goto bad; } #endif - + nxt = (*inet6sw[ip6_protox[nxt]].pr_input)(&m, &off, nxt); } return; @@ -767,17 +770,8 @@ ip6_hopopts_input(plenp, rtalertp, mp, o struct mbuf *m = *mp; int off = *offp, hbhlen; struct ip6_hbh *hbh; - u_int8_t *opt; /* validation of the length of the header */ -#ifndef PULLDOWN_TEST - IP6_EXTHDR_CHECK(m, off, sizeof(*hbh), -1); - hbh = (struct ip6_hbh *)(mtod(m, caddr_t) + off); - hbhlen = (hbh->ip6h_len + 1) << 3; - - IP6_EXTHDR_CHECK(m, off, hbhlen, -1); - hbh = (struct ip6_hbh *)(mtod(m, caddr_t) + off); -#else IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr), sizeof(struct ip6_hbh)); if (hbh == NULL) { @@ -791,18 +785,17 @@ ip6_hopopts_input(plenp, rtalertp, mp, o ip6stat.ip6s_tooshort++; return -1; } -#endif + KASSERT(IP6_HDR_ALIGNED_P(hbh)); off += hbhlen; hbhlen -= sizeof(struct ip6_hbh); - opt = (u_int8_t *)hbh + sizeof(struct ip6_hbh); if (ip6_process_hopopts(m, (u_int8_t *)hbh + sizeof(struct ip6_hbh), hbhlen, rtalertp, plenp) < 0) - return(-1); + return (-1); *offp = off; *mp = m; - return(0); + return (0); } /* @@ -810,6 +803,10 @@ ip6_hopopts_input(plenp, rtalertp, mp, o * This function is separate from ip6_hopopts_input() in order to * handle a case where the sending node itself process its hop-by-hop * options header. In such a case, the function is called from ip6_output(). + * + * The function assumes that hbh header is located right after the IPv6 header + * (RFC2460 p7), opthead is pointer into data content in m, and opthead to + * opthead + hbhlen is located in continuous memory region. */ int ip6_process_hopopts(m, opthead, hbhlen, rtalertp, plenp) @@ -824,6 +821,7 @@ ip6_process_hopopts(m, opthead, hbhlen, u_int8_t *opt = opthead; u_int16_t rtalert_val; u_int32_t jumboplen; + const int erroff = sizeof(struct ip6_hdr) + sizeof(struct ip6_hbh); for (; hbhlen > 0; hbhlen -= optlen, opt += optlen) { switch (*opt) { @@ -844,9 +842,11 @@ ip6_process_hopopts(m, opthead, hbhlen, goto bad; } if (*(opt + 1) != IP6OPT_RTALERT_LEN - 2) { - /* XXX: should we discard the packet? */ - log(LOG_ERR, "length of router alert opt is inconsitent(%d)", - *(opt + 1)); + /* XXX stat */ + icmp6_error(m, ICMP6_PARAM_PROB, + ICMP6_PARAMPROB_HEADER, + erroff + opt + 1 - opthead); + return (-1); } optlen = IP6OPT_RTALERT_LEN; bcopy((caddr_t)(opt + 2), (caddr_t)&rtalert_val, 2); @@ -859,10 +859,11 @@ ip6_process_hopopts(m, opthead, hbhlen, goto bad; } if (*(opt + 1) != IP6OPT_JUMBO_LEN - 2) { - /* XXX: should we discard the packet? */ - log(LOG_ERR, "length of jumbopayload opt " - "is inconsistent(%d)\n", - *(opt + 1)); + /* XXX stat */ + icmp6_error(m, ICMP6_PARAM_PROB, + ICMP6_PARAMPROB_HEADER, + erroff + opt + 1 - opthead); + return (-1); } optlen = IP6OPT_JUMBO_LEN; @@ -874,11 +875,9 @@ ip6_process_hopopts(m, opthead, hbhlen, if (ip6->ip6_plen) { ip6stat.ip6s_badoptions++; icmp6_error(m, ICMP6_PARAM_PROB, - ICMP6_PARAMPROB_HEADER, - sizeof(struct ip6_hdr) + - sizeof(struct ip6_hbh) + - opt - opthead); - return(-1); + ICMP6_PARAMPROB_HEADER, + erroff + opt - opthead); + return (-1); } /* @@ -900,11 +899,9 @@ ip6_process_hopopts(m, opthead, hbhlen, if (*plenp != 0) { ip6stat.ip6s_badoptions++; icmp6_error(m, ICMP6_PARAM_PROB, - ICMP6_PARAMPROB_HEADER, - sizeof(struct ip6_hdr) + - sizeof(struct ip6_hbh) + - opt + 2 - opthead); - return(-1); + ICMP6_PARAMPROB_HEADER, + erroff + opt + 2 - opthead); + return (-1); } #endif @@ -914,11 +911,9 @@ ip6_process_hopopts(m, opthead, hbhlen, if (jumboplen <= IPV6_MAXPACKET) { ip6stat.ip6s_badoptions++; icmp6_error(m, ICMP6_PARAM_PROB, - ICMP6_PARAMPROB_HEADER, - sizeof(struct ip6_hdr) + - sizeof(struct ip6_hbh) + - opt + 2 - opthead); - return(-1); + ICMP6_PARAMPROB_HEADER, + erroff + opt + 2 - opthead); + return (-1); } *plenp = jumboplen; @@ -928,21 +923,20 @@ ip6_process_hopopts(m, opthead, hbhlen, ip6stat.ip6s_toosmall++; goto bad; } - if ((optlen = ip6_unknown_opt(opt, m, - sizeof(struct ip6_hdr) + - sizeof(struct ip6_hbh) + - opt - opthead)) == -1) - return(-1); + optlen = ip6_unknown_opt(opt, m, + erroff + opt - opthead); + if (optlen == -1) + return (-1); optlen += 2; break; } } - return(0); + return (0); bad: m_freem(m); - return(-1); + return (-1); } /* @@ -961,14 +955,14 @@ ip6_unknown_opt(optp, m, off) switch (IP6OPT_TYPE(*optp)) { case IP6OPT_TYPE_SKIP: /* ignore the option */ - return((int)*(optp + 1)); + return ((int)*(optp + 1)); case IP6OPT_TYPE_DISCARD: /* silently discard */ m_freem(m); - return(-1); + return (-1); case IP6OPT_TYPE_FORCEICMP: /* send ICMP even if multicasted */ ip6stat.ip6s_badoptions++; icmp6_error(m, ICMP6_PARAM_PROB, ICMP6_PARAMPROB_OPTION, off); - return(-1); + return (-1); case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */ ip6stat.ip6s_badoptions++; ip6 = mtod(m, struct ip6_hdr *); @@ -978,11 +972,11 @@ ip6_unknown_opt(optp, m, off) else icmp6_error(m, ICMP6_PARAM_PROB, ICMP6_PARAMPROB_OPTION, off); - return(-1); + return (-1); } m_freem(m); /* XXX: NOTREACHED */ - return(-1); + return (-1); } /* @@ -1016,15 +1010,14 @@ ip6_savecontrol(in6p, mp, ip6, m) microtime(&tv); *mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv), - SCM_TIMESTAMP, SOL_SOCKET); + SCM_TIMESTAMP, SOL_SOCKET); if (*mp) mp = &(*mp)->m_next; } #endif if (in6p->in6p_flags & IN6P_RECVDSTADDR) { *mp = sbcreatecontrol((caddr_t) &ip6->ip6_dst, - sizeof(struct in6_addr), IPV6_RECVDSTADDR, - IPPROTO_IPV6); + sizeof(struct in6_addr), IPV6_RECVDSTADDR, IPPROTO_IPV6); if (*mp) mp = &(*mp)->m_next; } @@ -1048,15 +1041,14 @@ ip6_savecontrol(in6p, mp, ip6, m) ? m->m_pkthdr.rcvif->if_index : 0; *mp = sbcreatecontrol((caddr_t) &pi6, - sizeof(struct in6_pktinfo), IPV6_PKTINFO, - IPPROTO_IPV6); + sizeof(struct in6_pktinfo), IPV6_PKTINFO, IPPROTO_IPV6); if (*mp) mp = &(*mp)->m_next; } if (in6p->in6p_flags & IN6P_HOPLIMIT) { int hlim = ip6->ip6_hlim & 0xff; - *mp = sbcreatecontrol((caddr_t) &hlim, - sizeof(int), IPV6_HOPLIMIT, IPPROTO_IPV6); + *mp = sbcreatecontrol((caddr_t) &hlim, sizeof(int), + IPV6_HOPLIMIT, IPPROTO_IPV6); if (*mp) mp = &(*mp)->m_next; } @@ -1080,25 +1072,21 @@ ip6_savecontrol(in6p, mp, ip6, m) if (ip6->ip6_nxt == IPPROTO_HOPOPTS) { struct ip6_hbh *hbh; int hbhlen; + struct mbuf *ext; -#ifndef PULLDOWN_TEST - hbh = (struct ip6_hbh *)(ip6 + 1); - hbhlen = (hbh->ip6h_len + 1) << 3; -#else - IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, - sizeof(struct ip6_hdr), sizeof(struct ip6_hbh)); - if (hbh == NULL) { + ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr), + ip6->ip6_nxt); + if (ext == NULL) { ip6stat.ip6s_tooshort++; return; } + hbh = mtod(ext, struct ip6_hbh *); hbhlen = (hbh->ip6h_len + 1) << 3; - IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, - sizeof(struct ip6_hdr), hbhlen); - if (hbh == NULL) { + if (hbhlen != ext->m_len) { + m_freem(ext); ip6stat.ip6s_tooshort++; return; } -#endif /* * XXX: We copy whole the header even if a jumbo @@ -1107,16 +1095,17 @@ ip6_savecontrol(in6p, mp, ip6, m) * But it's too painful operation... */ *mp = sbcreatecontrol((caddr_t)hbh, hbhlen, - IPV6_HOPOPTS, IPPROTO_IPV6); + IPV6_HOPOPTS, IPPROTO_IPV6); if (*mp) mp = &(*mp)->m_next; + m_freem(ext); } } /* IPV6_DSTOPTS and IPV6_RTHDR socket options */ if (in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) { struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); - int nxt = ip6->ip6_nxt, off = sizeof(struct ip6_hdr);; + int nxt = ip6->ip6_nxt, off = sizeof(struct ip6_hdr); /* * Search for destination options headers or routing @@ -1126,35 +1115,43 @@ ip6_savecontrol(in6p, mp, ip6, m) * the chain of ancillary data. */ while (1) { /* is explicit loop prevention necessary? */ - struct ip6_ext *ip6e; + struct ip6_ext *ip6e = NULL; int elen; + struct mbuf *ext = NULL; -#ifndef PULLDOWN_TEST - ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + off); - if (nxt == IPPROTO_AH) - elen = (ip6e->ip6e_len + 2) << 2; - else - elen = (ip6e->ip6e_len + 1) << 3; -#else - IP6_EXTHDR_GET(ip6e, struct ip6_ext *, m, off, - sizeof(struct ip6_ext)); - if (ip6e == NULL) { + /* + * if it is not an extension header, don't try to + * pull it from the chain. + */ + switch (nxt) { + case IPPROTO_DSTOPTS: + case IPPROTO_ROUTING: + case IPPROTO_HOPOPTS: + case IPPROTO_AH: /* is it possible? */ + break; + default: + goto loopend; + } + + ext = ip6_pullexthdr(m, off, nxt); + if (ext == NULL) { ip6stat.ip6s_tooshort++; return; } + ip6e = mtod(ext, struct ip6_ext *); if (nxt == IPPROTO_AH) elen = (ip6e->ip6e_len + 2) << 2; else elen = (ip6e->ip6e_len + 1) << 3; - IP6_EXTHDR_GET(ip6e, struct ip6_ext *, m, off, elen); - if (ip6e == NULL) { + if (elen != ext->m_len) { + m_freem(ext); ip6stat.ip6s_tooshort++; return; } -#endif + KASSERT(IP6_HDR_ALIGNED_P(ip6e)); switch (nxt) { - case IPPROTO_DSTOPTS: + case IPPROTO_DSTOPTS: if (!in6p->in6p_flags & IN6P_DSTOPTS) break; @@ -1167,8 +1164,7 @@ ip6_savecontrol(in6p, mp, ip6, m) break; *mp = sbcreatecontrol((caddr_t)ip6e, elen, - IPV6_DSTOPTS, - IPPROTO_IPV6); + IPV6_DSTOPTS, IPPROTO_IPV6); if (*mp) mp = &(*mp)->m_next; break; @@ -1178,42 +1174,91 @@ ip6_savecontrol(in6p, mp, ip6, m) break; *mp = sbcreatecontrol((caddr_t)ip6e, elen, - IPV6_RTHDR, - IPPROTO_IPV6); + IPV6_RTHDR, IPPROTO_IPV6); if (*mp) mp = &(*mp)->m_next; break; - case IPPROTO_UDP: - case IPPROTO_TCP: - case IPPROTO_ICMPV6: + case IPPROTO_HOPOPTS: + case IPPROTO_AH: /* is it possible? */ + break; + default: /* - * stop search if we encounter an upper - * layer protocol headers. + * other cases have been filtered in the above. + * none will visit this case. here we supply + * the code just in case (nxt overwritten or + * other cases). */ + m_freem(ext); goto loopend; - case IPPROTO_HOPOPTS: - case IPPROTO_AH: /* is it possible? */ - break; } /* proceed with the next header. */ off += elen; nxt = ip6e->ip6e_nxt; + ip6e = NULL; + m_freem(ext); + ext = NULL; } loopend: - ; + ; + } +} + +/* + * pull single extension header from mbuf chain. returns single mbuf that + * contains the result, or NULL on error. + */ +static struct mbuf * +ip6_pullexthdr(m, off, nxt) + struct mbuf *m; + size_t off; + int nxt; +{ + struct ip6_ext ip6e; + size_t elen; + struct mbuf *n; + +#ifdef DIAGNOSTIC + switch (nxt) { + case IPPROTO_DSTOPTS: + case IPPROTO_ROUTING: + case IPPROTO_HOPOPTS: + case IPPROTO_AH: /* is it possible? */ + break; + default: + printf("ip6_pullexthdr: invalid nxt=%d\n", nxt); } - if ((in6p->in6p_flags & IN6P_HOPOPTS) && privileged) { - /* to be done */ +#endif + + m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e); + if (nxt == IPPROTO_AH) + elen = (ip6e.ip6e_len + 2) << 2; + else + elen = (ip6e.ip6e_len + 1) << 3; + + MGET(n, M_DONTWAIT, MT_DATA); + if (n && elen >= MLEN) { + MCLGET(n, M_DONTWAIT); + if ((n->m_flags & M_EXT) == 0) { + m_free(n); + n = NULL; + } } - if ((in6p->in6p_flags & IN6P_DSTOPTS) && privileged) { - /* to be done */ + if (!n) + return NULL; + + n->m_len = 0; + if (elen >= M_TRAILINGSPACE(n)) { + m_free(n); + return NULL; } - /* IN6P_RTHDR - to be done */ + m_copydata(m, off, elen, mtod(n, caddr_t)); + n->m_len = elen; + return n; } /* @@ -1228,7 +1273,7 @@ ip6_savecontrol(in6p, mp, ip6, m) * carefully. Moreover, it will not be used in the near future when * we develop `neater' mechanism to process extension headers. */ -char * +u_int8_t * ip6_get_prevhdr(m, off) struct mbuf *m; int off; @@ -1236,7 +1281,7 @@ ip6_get_prevhdr(m, off) struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); if (off == sizeof(struct ip6_hdr)) - return(&ip6->ip6_nxt); + return (&ip6->ip6_nxt); else { int len, nxt; struct ip6_ext *ip6e = NULL; @@ -1260,7 +1305,7 @@ ip6_get_prevhdr(m, off) nxt = ip6e->ip6e_nxt; } if (ip6e) - return(&ip6e->ip6e_nxt); + return (&ip6e->ip6e_nxt); else return NULL; } @@ -1304,7 +1349,7 @@ ip6_nexthdr(m, off, proto, nxtp) if (m->m_pkthdr.len < off + sizeof(fh)) return -1; m_copydata(m, off, sizeof(fh), (caddr_t)&fh); - if ((ntohs(fh.ip6f_offlg) & IP6F_OFF_MASK) != 0) + if ((fh.ip6f_offlg & IP6F_OFF_MASK) != 0) return -1; if (nxtp) *nxtp = fh.ip6f_nxt; @@ -1318,6 +1363,8 @@ ip6_nexthdr(m, off, proto, nxtp) if (nxtp) *nxtp = ip6e.ip6e_nxt; off += (ip6e.ip6e_len + 2) << 2; + if (m->m_pkthdr.len < off) + return -1; return off; case IPPROTO_HOPOPTS: @@ -1329,6 +1376,8 @@ ip6_nexthdr(m, off, proto, nxtp) if (nxtp) *nxtp = ip6e.ip6e_nxt; off += (ip6e.ip6e_len + 1) << 3; + if (m->m_pkthdr.len < off) + return -1; return off; case IPPROTO_NONE: @@ -1340,8 +1389,6 @@ ip6_nexthdr(m, off, proto, nxtp) default: return -1; } - - return -1; } /* @@ -1388,125 +1435,173 @@ u_char inet6ctlerrmap[PRC_NCMDS] = { ENOPROTOOPT }; -#include -#include - -int -ip6_sysctl(name, namelen, oldp, oldlenp, newp, newlen) - int *name; - u_int namelen; - void *oldp; - size_t *oldlenp; - void *newp; - size_t newlen; +SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup") { - int old, error; - /* All sysctl names at this level are terminal. */ - if (namelen != 1) - return ENOTDIR; - - switch (name[0]) { - - case IPV6CTL_FORWARDING: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_forwarding); - case IPV6CTL_SENDREDIRECTS: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_sendredirects); - case IPV6CTL_DEFHLIM: - return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_defhlim); - case IPV6CTL_MAXFRAGPACKETS: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_maxfragpackets); - case IPV6CTL_ACCEPT_RTADV: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_accept_rtadv); - case IPV6CTL_KEEPFAITH: - return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_keepfaith); - case IPV6CTL_LOG_INTERVAL: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_log_interval); - case IPV6CTL_HDRNESTLIMIT: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_hdrnestlimit); - case IPV6CTL_DAD_COUNT: - return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_dad_count); - case IPV6CTL_AUTO_FLOWLABEL: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_auto_flowlabel); - case IPV6CTL_DEFMCASTHLIM: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_defmcasthlim); - case IPV6CTL_GIF_HLIM: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_gif_hlim); - case IPV6CTL_KAME_VERSION: - return sysctl_rdstring(oldp, oldlenp, newp, __KAME_VERSION); - case IPV6CTL_USE_DEPRECATED: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_use_deprecated); - case IPV6CTL_RR_PRUNE: - return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_rr_prune); + sysctl_createv(SYSCTL_PERMANENT, + CTLTYPE_NODE, "net", NULL, + NULL, 0, NULL, 0, + CTL_NET, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT, + CTLTYPE_NODE, "inet6", NULL, + NULL, 0, NULL, 0, + CTL_NET, PF_INET6, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT, + CTLTYPE_NODE, "ip6", NULL, + NULL, 0, NULL, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_EOL); + + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "forwarding", NULL, + NULL, 0, &ip6_forwarding, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_FORWARDING, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "redirect", NULL, + NULL, 0, &ip6_sendredirects, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_SENDREDIRECTS, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "hlim", NULL, + NULL, 0, &ip6_defhlim, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_DEFHLIM, CTL_EOL); +#ifdef notyet + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "mtu", NULL, + NULL, 0, &, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_DEFMTU, CTL_EOL); +#endif +#ifdef __no_idea__ + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "forwsrcrt", NULL, + NULL, 0, &?, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_FORWSRCRT, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_STRUCT, "stats", NULL, + NULL, 0, &?, sizeof(?), + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_STATS, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_STRUCT, "mrtstats", NULL, + NULL, 0, &?, sizeof(?), + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_MRTSTATS, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_?, "mrtproto", NULL, + NULL, 0, &?, sizeof(?), + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_MRTPROTO, CTL_EOL); +#endif + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "maxfragpackets", NULL, + NULL, 0, &ip6_maxfragpackets, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_MAXFRAGPACKETS, CTL_EOL); +#ifdef __no_idea__ + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "sourcecheck", NULL, + NULL, 0, &?, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_SOURCECHECK, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "sourcecheck_logint", NULL, + NULL, 0, &?, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_SOURCECHECK_LOGINT, CTL_EOL); +#endif + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "accept_rtadv", NULL, + NULL, 0, &ip6_accept_rtadv, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_ACCEPT_RTADV, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "keepfaith", NULL, + NULL, 0, &ip6_keepfaith, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_KEEPFAITH, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "log_interval", NULL, + NULL, 0, &ip6_log_interval, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_LOG_INTERVAL, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "hdrnestlimit", NULL, + NULL, 0, &ip6_hdrnestlimit, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_HDRNESTLIMIT, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "dad_count", NULL, + NULL, 0, &ip6_dad_count, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_DAD_COUNT, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "auto_flowlabel", NULL, + NULL, 0, &ip6_auto_flowlabel, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_AUTO_FLOWLABEL, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "defmcasthlim", NULL, + NULL, 0, &ip6_defmcasthlim, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_DEFMCASTHLIM, CTL_EOL); +#if NGIF > 0 + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "gifhlim", NULL, + NULL, 0, &ip6_gif_hlim, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_GIF_HLIM, CTL_EOL); +#endif /* NGIF */ + sysctl_createv(SYSCTL_PERMANENT, + CTLTYPE_STRING, "kame_version", NULL, + NULL, 0, __KAME_VERSION, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_KAME_VERSION, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "use_deprecated", NULL, + NULL, 0, &ip6_use_deprecated, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_USE_DEPRECATED, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "rr_prune", NULL, + NULL, 0, &ip6_rr_prune, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_RR_PRUNE, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT #ifndef INET6_BINDV6ONLY - case IPV6CTL_BINDV6ONLY: - return sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_bindv6only); -#endif - case IPV6CTL_ANONPORTMIN: - old = ip6_anonportmin; - error = sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_anonportmin); - if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmin < 0 || - ip6_anonportmin > 65535 -#ifndef IPNOPRIVPORTS - || ip6_anonportmin < IPV6PORT_RESERVED + |SYSCTL_READWRITE, #endif - ) { - ip6_anonportmin = old; - return (EINVAL); - } - return (error); - case IPV6CTL_ANONPORTMAX: - old = ip6_anonportmax; - error = sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_anonportmax); - if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmax < 0 || - ip6_anonportmax > 65535 + CTLTYPE_INT, "v6only", NULL, + NULL, 0, &ip6_v6only, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_V6ONLY, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "anonportmin", NULL, + sysctl_net_inet_ip_ports, 0, &ip6_anonportmin, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_ANONPORTMIN, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "anonportmax", NULL, + sysctl_net_inet_ip_ports, 0, &ip6_anonportmax, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_ANONPORTMAX, CTL_EOL); #ifndef IPNOPRIVPORTS - || ip6_anonportmax < IPV6PORT_RESERVED -#endif - ) { - ip6_anonportmax = old; - return (EINVAL); - } - return (error); -#ifndef IPNOPRIVPORTS - case IPV6CTL_LOWPORTMIN: - old = ip6_lowportmin; - error = sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_lowportmin); - if (ip6_lowportmin >= ip6_lowportmax || - ip6_lowportmin > IPV6PORT_RESERVEDMAX || - ip6_lowportmin < IPV6PORT_RESERVEDMIN) { - ip6_lowportmin = old; - return (EINVAL); - } - return (error); - case IPV6CTL_LOWPORTMAX: - old = ip6_lowportmax; - error = sysctl_int(oldp, oldlenp, newp, newlen, - &ip6_lowportmax); - if (ip6_lowportmin >= ip6_lowportmax || - ip6_lowportmax > IPV6PORT_RESERVEDMAX || - ip6_lowportmax < IPV6PORT_RESERVEDMIN) { - ip6_lowportmax = old; - return (EINVAL); - } - return (error); -#endif - default: - return EOPNOTSUPP; - } - /* NOTREACHED */ + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "lowportmin", NULL, + sysctl_net_inet_ip_ports, 0, &ip6_lowportmin, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_LOWPORTMIN, CTL_EOL); + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "lowportmax", NULL, + sysctl_net_inet_ip_ports, 0, &ip6_lowportmax, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_LOWPORTMAX, CTL_EOL); +#endif /* IPNOPRIVPORTS */ + sysctl_createv(SYSCTL_PERMANENT|SYSCTL_READWRITE, + CTLTYPE_INT, "maxfrags", NULL, + NULL, 0, &ip6_maxfrags, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_MAXFRAGS, CTL_EOL); }