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 retrieving revision 1.8.2.7 retrieving revision 1.9 diff -u -p -r1.8.2.7 -r1.9 --- src/sys/netinet6/ip6_input.c 2001/04/21 17:46:55 1.8.2.7 +++ src/sys/netinet6/ip6_input.c 1999/12/13 15:17:22 1.9 @@ -1,10 +1,9 @@ -/* $NetBSD: ip6_input.c,v 1.8.2.7 2001/04/21 17:46:55 bouyer Exp $ */ -/* $KAME: ip6_input.c,v 1.188 2001/03/29 05:34:31 itojun Exp $ */ +/* $NetBSD: ip6_input.c,v 1.9 1999/12/13 15:17:22 itojun Exp $ */ /* * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. * All rights reserved. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: @@ -16,7 +15,7 @@ * 3. Neither the name of the project nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. - * + * * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -65,9 +64,15 @@ * @(#)ip_input.c 8.2 (Berkeley) 1/4/94 */ +#ifdef __FreeBSD__ +#include "opt_ip6fw.h" +#endif +#if (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(__NetBSD__) #include "opt_inet.h" +#ifdef __NetBSD__ /*XXX*/ #include "opt_ipsec.h" -#include "opt_pfil_hooks.h" +#endif +#endif #include #include @@ -81,16 +86,15 @@ #include #include #include +#if !defined(__bsdi__) && !(defined(__FreeBSD__) && __FreeBSD__ < 3) #include +#endif #include #include #include #include #include -#ifdef PFIL_HOOKS -#include -#endif #include #include @@ -98,23 +102,30 @@ #include #include #endif /*INET*/ -#include +#if (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(__OpenBSD__) || (defined(__bsdi__) && _BSDI_VERSION >= 199802) +#include +#endif #include -#include +#include +#if !((defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(__OpenBSD__) || (defined(__bsdi__) && _BSDI_VERSION >= 199802)) #include -#include +#endif +#include +#include #include #include #include -#ifdef IPSEC -#include +#ifdef IPV6FIREWALL +#include #endif #include /* we need it for NLOOP. */ +#ifndef __bsdi__ #include "loop.h" +#endif #include "faith.h" #include "gif.h" @@ -122,20 +133,36 @@ #include +#ifdef __OpenBSD__ /*KAME IPSEC*/ +#undef IPSEC +#endif + extern struct domain inet6domain; +extern struct ip6protosw inet6sw[]; +#ifdef __bsdi__ +#if _BSDI_VERSION < 199802 +extern struct ifnet loif; +#else +extern struct ifnet *loifp; +#endif +#endif u_char ip6_protox[IPPROTO_MAX]; static int ip6qmaxlen = IFQ_MAXLEN; struct in6_ifaddr *in6_ifaddr; struct ifqueue ip6intrq; +#if defined(__NetBSD__) || defined(__OpenBSD__) extern struct ifnet loif[NLOOP]; +#endif int ip6_forward_srcrt; /* XXX */ int ip6_sourcecheck; /* XXX */ int ip6_sourcecheck_interval; /* XXX */ -#ifdef PFIL_HOOKS -struct pfil_head inet6_pfil_hook; +#ifdef IPV6FIREWALL +/* firewall hooks */ +ip6_fw_chk_t *ip6_fw_chk_ptr; +ip6_fw_ctl_t *ip6_fw_ctl_ptr; #endif struct ip6stat ip6stat; @@ -144,6 +171,13 @@ static void ip6_init2 __P((void *)); static int ip6_hopopts_input __P((u_int32_t *, u_int32_t *, struct mbuf **, int *)); +#if defined(PTR) +extern int ip6_protocol_tr; + +int ptr_in6 __P((struct mbuf *, struct mbuf **)); +extern void ip_forward __P((struct mbuf *, int)); +#endif + /* * IP6 initialization: fill in IP6 protocol switch table. * All protocols not implemented in kernel go to raw IP6 protocol handler. @@ -151,8 +185,8 @@ static int ip6_hopopts_input __P((u_int3 void ip6_init() { - struct ip6protosw *pr; - int i; + register struct ip6protosw *pr; + register int i; struct timeval tv; pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW); @@ -168,6 +202,9 @@ ip6_init() ip6intrq.ifq_maxlen = ip6qmaxlen; nd6_init(); frag6_init(); +#ifdef IPV6FIREWALL + ip6_fw_init(); +#endif /* * in many cases, random() here does NOT return random number * as initialization during bootstrap time occur in fixed order. @@ -175,37 +212,44 @@ ip6_init() microtime(&tv); ip6_flow_seq = random() ^ tv.tv_usec; +#ifndef __FreeBSD__ ip6_init2((void *)0); - -#ifdef PFIL_HOOKS - /* Register our Packet Filter hook. */ - inet6_pfil_hook.ph_type = PFIL_TYPE_AF; - inet6_pfil_hook.ph_af = AF_INET6; - i = pfil_head_register(&inet6_pfil_hook); - if (i != 0) - printf("ip6_init: WARNING: unable to register pfil hook, " - "error %d\n", i); -#endif /* PFIL_HOOKS */ +#endif } static void ip6_init2(dummy) void *dummy; { + int ret; +#if defined(__bsdi__) && _BSDI_VERSION < 199802 + struct ifnet *loifp = &loif; +#endif + + /* get EUI64 from somewhere */ + ret = in6_ifattach_getifid(NULL); + /* * to route local address of p2p link to loopback, - * assign loopback address first. + * assign loopback address first. */ - in6_ifattach(&loif[0], NULL); +#ifdef __bsdi__ + in6_ifattach(loifp, IN6_IFT_LOOP, NULL, 0); +#else + in6_ifattach(&loif[0], IN6_IFT_LOOP, NULL, 0); +#endif /* nd6_timer_init */ - callout_init(&nd6_timer_ch); - callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL); + timeout(nd6_timer, (caddr_t)0, hz); /* router renumbering prefix list maintenance */ - callout_init(&in6_rr_timer_ch); - callout_reset(&in6_rr_timer_ch, hz, in6_rr_timer, NULL); + timeout(in6_rr_timer, (caddr_t)0, hz); } +#ifdef __FreeBSD__ +/* cheat */ +SYSINIT(netinet6init2, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, ip6_init2, NULL); +#endif + /* * IP6 input interrupt handling. Just pass the packet to ip6_input. */ @@ -216,7 +260,7 @@ ip6intr() struct mbuf *m; for (;;) { - s = splnet(); + s = splimp(); IF_DEQUEUE(&ip6intrq, m); splx(s); if (m == 0) @@ -225,6 +269,10 @@ ip6intr() } } +#ifdef __FreeBSD__ +NETISR_SET(NETISR_IPV6, ip6intr); +#endif + extern struct route_in6 ip6_forward_rt; void @@ -237,6 +285,9 @@ ip6_input(m) u_int32_t rtalert = ~0; int nxt, ours = 0; struct ifnet *deliverifp = NULL; +#if defined(__bsdi__) && _BSDI_VERSION < 199802 + struct ifnet *loifp = &loif; +#endif #ifdef IPSEC /* @@ -258,17 +309,20 @@ 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) { +#ifdef __bsdi__ + ip6stat.ip6s_m2m[loifp->if_index]++; /*XXX*/ +#else ip6stat.ip6s_m2m[loif[0].if_index]++; /*XXX*/ - } else if (m->m_pkthdr.rcvif->if_index < M2MMAX) +#endif + } + else if (m->m_pkthdr.rcvif->if_index <= 31) 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); @@ -297,41 +351,22 @@ ip6_input(m) goto bad; } -#ifdef PFIL_HOOKS - /* - * Run through list of hooks for input packets. If there are any - * filters which require that additional packets in the flow are - * not fast-forwarded, they must clear the M_CANFASTFWD flag. - * Note that filters must _never_ set this flag, as another filter - * in the list may have previously cleared it. - */ + ip6stat.ip6s_nxthist[ip6->ip6_nxt]++; + +#ifdef IPV6FIREWALL /* - * let ipfilter look at packet on the wire, - * not the decapsulated packet. + * Check with the firewall... */ -#ifdef IPSEC - if (!ipsec_gethist(m, NULL)) -#else - if (1) -#endif - { - if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.rcvif, - PFIL_IN) != 0) - return; - if (m == NULL) + if (ip6_fw_chk_ptr) { + u_short port = 0; + /* If ipfw says divert, we have to just drop packet */ + /* use port as a dummy argument */ + if ((*ip6_fw_chk_ptr)(&ip6, NULL, &port, &m)) { + m_freem(m); + m = NULL; + } + if (!m) return; - ip6 = mtod(m, struct ip6_hdr *); - } -#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; } #endif @@ -344,40 +379,6 @@ ip6_input(m) 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. - * - * 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. - */ - if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) || - IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) { - ip6stat.ip6s_badscope++; - in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr); - goto bad; - } -#if 0 - /* - * Reject packets with IPv4 compatible addresses (auto tunnel). - * - * The code forbids auto tunnel relay case in RFC1933 (the check is - * stronger than RFC1933). We may want to re-enable it if mech-xx - * is revised to forbid relaying case. - */ - if (IN6_IS_ADDR_V4COMPAT(&ip6->ip6_src) || - IN6_IS_ADDR_V4COMPAT(&ip6->ip6_dst)) { - ip6stat.ip6s_badscope++; - in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr); - goto bad; - } -#endif - if (IN6_IS_ADDR_LOOPBACK(&ip6->ip6_src) || IN6_IS_ADDR_LOOPBACK(&ip6->ip6_dst)) { if (m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) { @@ -391,50 +392,47 @@ ip6_input(m) } } - /* drop packets if interface ID portion is already filled */ - if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) { - if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src) && - ip6->ip6_src.s6_addr16[1]) { - ip6stat.ip6s_badscope++; - goto bad; - } - if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst) && - ip6->ip6_dst.s6_addr16[1]) { - ip6stat.ip6s_badscope++; - goto bad; + if (m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) { + if (IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_dst)) { + ours = 1; + deliverifp = m->m_pkthdr.rcvif; + goto hbhcheck; } + } else { + 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); } - 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); - +#if defined(PTR) /* - * 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; - } + if (ip6_protocol_tr) + { + struct mbuf *m1 = NULL; - ours = 1; - deliverifp = m->m_pkthdr.rcvif; - goto hbhcheck; + switch (ptr_in6(m, &m1)) + { + case IPPROTO_IP: goto mcastcheck; + case IPPROTO_IPV4: ip_forward(m1, 0); break; + case IPPROTO_IPV6: ip6_forward(m1, 0); break; + case IPPROTO_MAX: /* discard this packet */ + default: + } + + if (m != m1) + m_freem(m); + + return; } + mcastcheck: +#endif + /* * Multicast check */ @@ -462,28 +460,23 @@ ip6_input(m) /* * Unicast check */ - if (ip6_forward_rt.ro_rt != NULL && - (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++; - else { - struct sockaddr_in6 *dst6; - + if (ip6_forward_rt.ro_rt == 0 || + !IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, + &ip6_forward_rt.ro_dst.sin6_addr)) { if (ip6_forward_rt.ro_rt) { - /* route is down or destination is different */ - ip6stat.ip6s_forward_cachemiss++; RTFREE(ip6_forward_rt.ro_rt); ip6_forward_rt.ro_rt = 0; } - bzero(&ip6_forward_rt.ro_dst, sizeof(struct sockaddr_in6)); - dst6 = (struct sockaddr_in6 *)&ip6_forward_rt.ro_dst; - dst6->sin6_len = sizeof(struct sockaddr_in6); - dst6->sin6_family = AF_INET6; - dst6->sin6_addr = ip6->ip6_dst; + ip6_forward_rt.ro_dst.sin6_len = sizeof(struct sockaddr_in6); + ip6_forward_rt.ro_dst.sin6_family = AF_INET6; + ip6_forward_rt.ro_dst.sin6_addr = ip6->ip6_dst; +#ifdef __FreeBSD__ + rtalloc_ign((struct route *)&ip6_forward_rt, RTF_PRCLONING); +#else rtalloc((struct route *)&ip6_forward_rt); +#endif } #define rt6_key(r) ((struct sockaddr_in6 *)((r)->rt_nodes->rn_key)) @@ -512,25 +505,16 @@ ip6_input(m) ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_LOOP) { struct in6_ifaddr *ia6 = (struct in6_ifaddr *)ip6_forward_rt.ro_rt->rt_ifa; + /* packet to tentative address must not be received */ if (ia6->ia6_flags & IN6_IFF_ANYCAST) m->m_flags |= M_ANYCAST6; - /* - * packets to a tentative, duplicated, or somehow invalid - * address must not be accepted. - */ if (!(ia6->ia6_flags & IN6_IFF_NOTREADY)) { - /* this address is ready */ + /* this interface is ready */ ours = 1; deliverifp = ia6->ia_ifp; /* correct? */ goto hbhcheck; } else { - /* address is not ready, so discard the packet. */ - nd6log((LOG_INFO, - "ip6_input: packet to an unready address %s->%s\n", - ip6_sprintf(&ip6->ip6_src), - ip6_sprintf(&ip6->ip6_dst))); - - goto bad; + /* this interface is not ready, fall through */ } } @@ -599,29 +583,8 @@ ip6_input(m) #endif return; /* m have already been freed */ } - /* adjust pointer */ ip6 = mtod(m, struct ip6_hdr *); - - /* - * 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. - */ - if (ip6->ip6_plen == 0 && plen == 0) { - /* - * 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. - */ - ip6stat.ip6s_badoptions++; - in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard); - in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr); - icmp6_error(m, ICMP6_PARAM_PROB, - ICMP6_PARAMPROB_HEADER, - (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); @@ -684,35 +647,19 @@ ip6_input(m) m_freem(m); return; } - } else if (!ours) { + } + else if (!ours) { ip6_forward(m, 0); return; } - ip6 = mtod(m, struct ip6_hdr *); - - /* - * 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. - * - * For SIIT end node behavior, you may want to disable the check. - * However, you will become vulnerable to attacks using IPv4 mapped - * source. - */ - if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) || - IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) { - ip6stat.ip6s_badscope++; - in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr); - goto bad; - } - /* * Tell launch routine the next header */ -#ifdef IFA_STATS - if (deliverifp != NULL) { +#if defined(__NetBSD__) && defined(IFA_STATS) + if (IFA_STATS && deliverifp != NULL) { struct in6_ifaddr *ia6; + ip6 = mtod(m, struct ip6_hdr *); ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst); if (ia6) ia6->ia_ifa.ifa_data.ifad_inbytes += m->m_pkthdr.len; @@ -721,7 +668,6 @@ 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++; @@ -738,19 +684,6 @@ ip6_input(m) goto bad; } -#ifdef IPSEC - /* - * enforce IPsec policy checking if we are seeing last header. - * note that we do not visit this with protocols with pcb layer - * code - like udp/tcp/raw ip. - */ - if ((inet6sw[ip6_protox[nxt]].pr_flags & PR_LASTHDR) != 0 && - ipsec6_in_reject(m, NULL)) { - ipsec6stat.in_polvio++; - goto bad; - } -#endif - nxt = (*inet6sw[ip6_protox[nxt]].pr_input)(&m, &off, nxt); } return; @@ -769,7 +702,7 @@ ip6_hopopts_input(plenp, rtalertp, mp, o struct mbuf **mp; int *offp; { - struct mbuf *m = *mp; + register struct mbuf *m = *mp; int off = *offp, hbhlen; struct ip6_hbh *hbh; u_int8_t *opt; @@ -828,118 +761,97 @@ ip6_process_hopopts(m, opthead, hbhlen, int optlen = 0; u_int8_t *opt = opthead; u_int16_t rtalert_val; - u_int32_t jumboplen; for (; hbhlen > 0; hbhlen -= optlen, opt += optlen) { - switch (*opt) { - case IP6OPT_PAD1: - optlen = 1; - break; - case IP6OPT_PADN: - if (hbhlen < IP6OPT_MINLEN) { - ip6stat.ip6s_toosmall++; - goto bad; - } - optlen = *(opt + 1) + 2; - break; - case IP6OPT_RTALERT: - /* XXX may need check for alignment */ - if (hbhlen < IP6OPT_RTALERT_LEN) { - ip6stat.ip6s_toosmall++; - 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)); - } - optlen = IP6OPT_RTALERT_LEN; - bcopy((caddr_t)(opt + 2), (caddr_t)&rtalert_val, 2); - *rtalertp = ntohs(rtalert_val); - break; - case IP6OPT_JUMBO: - /* XXX may need check for alignment */ - if (hbhlen < IP6OPT_JUMBO_LEN) { - ip6stat.ip6s_toosmall++; - 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)); - } - optlen = IP6OPT_JUMBO_LEN; - - /* - * IPv6 packets that have non 0 payload length - * must not contain a jumbo payload option. - */ - ip6 = mtod(m, struct ip6_hdr *); - 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); - } - - /* - * We may see jumbolen in unaligned location, so - * we'd need to perform bcopy(). - */ - bcopy(opt + 2, &jumboplen, sizeof(jumboplen)); - jumboplen = (u_int32_t)htonl(jumboplen); - -#if 1 - /* - * if there are multiple jumbo payload options, - * *plenp will be non-zero and the packet will be - * rejected. - * the behavior may need some debate in ipngwg - - * multiple options does not make sense, however, - * there's no explicit mention in specification. - */ - 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); - } + switch(*opt) { + case IP6OPT_PAD1: + optlen = 1; + break; + case IP6OPT_PADN: + if (hbhlen < IP6OPT_MINLEN) { + ip6stat.ip6s_toosmall++; + goto bad; + } + optlen = *(opt + 1) + 2; + break; + case IP6OPT_RTALERT: + /* XXX may need check for alignment */ + if (hbhlen < IP6OPT_RTALERT_LEN) { + ip6stat.ip6s_toosmall++; + 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)); + optlen = IP6OPT_RTALERT_LEN; + bcopy((caddr_t)(opt + 2), (caddr_t)&rtalert_val, 2); + *rtalertp = ntohs(rtalert_val); + break; + case IP6OPT_JUMBO: + /* XXX may need check for alignment */ + if (hbhlen < IP6OPT_JUMBO_LEN) { + ip6stat.ip6s_toosmall++; + 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)", + *(opt + 1)); + optlen = IP6OPT_JUMBO_LEN; + + /* + * We can simply cast because of the alignment + * requirement of the jumbo payload option. + */ +#if 0 + *plenp = ntohl(*(u_int32_t *)(opt + 2)); +#else + bcopy(opt + 2, plenp, sizeof(*plenp)); + *plenp = htonl(*plenp); #endif - - /* - * jumbo payload length must be larger than 65535. - */ - 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); - } - *plenp = jumboplen; - - break; - default: /* unknown option */ - if (hbhlen < IP6OPT_MINLEN) { - 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 += 2; - break; + if (*plenp <= IPV6_MAXPACKET) { + /* + * jumbo payload length must be larger + * than 65535 + */ + 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); + } + + ip6 = mtod(m, struct ip6_hdr *); + if (ip6->ip6_plen) { + /* + * IPv6 packets that have non 0 payload length + * must not contain a jumbo paylod option. + */ + ip6stat.ip6s_badoptions++; + icmp6_error(m, ICMP6_PARAM_PROB, + ICMP6_PARAMPROB_HEADER, + sizeof(struct ip6_hdr) + + sizeof(struct ip6_hbh) + + opt - opthead); + return(-1); + } + break; + default: /* unknown option */ + if (hbhlen < IP6OPT_MINLEN) { + 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 += 2; + break; } } @@ -964,26 +876,26 @@ ip6_unknown_opt(optp, m, off) { struct ip6_hdr *ip6; - switch (IP6OPT_TYPE(*optp)) { - case IP6OPT_TYPE_SKIP: /* ignore the option */ - return((int)*(optp + 1)); - case IP6OPT_TYPE_DISCARD: /* silently discard */ - m_freem(m); - 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); - case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */ - ip6stat.ip6s_badoptions++; - ip6 = mtod(m, struct ip6_hdr *); - if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) || - (m->m_flags & (M_BCAST|M_MCAST))) - m_freem(m); - else - icmp6_error(m, ICMP6_PARAM_PROB, - ICMP6_PARAMPROB_OPTION, off); - return(-1); + switch(IP6OPT_TYPE(*optp)) { + case IP6OPT_TYPE_SKIP: /* ignore the option */ + return((int)*(optp + 1)); + case IP6OPT_TYPE_DISCARD: /* silently discard */ + m_freem(m); + 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); + case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */ + ip6stat.ip6s_badoptions++; + ip6 = mtod(m, struct ip6_hdr *); + if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) || + (m->m_flags & (M_BCAST|M_MCAST))) + m_freem(m); + else + icmp6_error(m, ICMP6_PARAM_PROB, + ICMP6_PARAMPROB_OPTION, off); + return(-1); } m_freem(m); /* XXX: NOTREACHED */ @@ -1003,17 +915,39 @@ ip6_unknown_opt(optp, m, off) */ void ip6_savecontrol(in6p, mp, ip6, m) - struct in6pcb *in6p; - struct mbuf **mp; - struct ip6_hdr *ip6; - struct mbuf *m; +#if (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(HAVE_NRL_INPCB) + register struct inpcb *in6p; +#else + register struct in6pcb *in6p; +#endif + register struct mbuf **mp; + register struct ip6_hdr *ip6; + register struct mbuf *m; { +#ifdef HAVE_NRL_INPCB +# define in6p_flags inp_flags +#endif +#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3) struct proc *p = curproc; /* XXX */ +#endif +#ifdef __bsdi__ +# define sbcreatecontrol so_cmsg +#endif int privileged; privileged = 0; +#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3) if (p && !suser(p->p_ucred, &p->p_acflag)) privileged++; +#else +#ifdef HAVE_NRL_INPCB + if ((in6p->inp_socket->so_state & SS_PRIV) != 0) + privileged++; +#else + if ((in6p->in6p_socket->so_state & SS_PRIV) != 0) + privileged++; +#endif +#endif #ifdef SO_TIMESTAMP if (in6p->in6p_socket->so_options & SO_TIMESTAMP) { @@ -1044,7 +978,7 @@ ip6_savecontrol(in6p, mp, ip6, m) #endif /* RFC 2292 sec. 5 */ - if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) { + if (in6p->in6p_flags & IN6P_PKTINFO) { struct in6_pktinfo pi6; bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr)); if (IN6_IS_SCOPE_LINKLOCAL(&pi6.ipi6_addr)) @@ -1073,7 +1007,7 @@ ip6_savecontrol(in6p, mp, ip6, m) * be some hop-by-hop options which can be returned to normal user. * See RFC 2292 section 6. */ - if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0 && privileged) { + if ((in6p->in6p_flags & IN6P_HOPOPTS) && privileged) { /* * Check if a hop-by-hop options header is contatined in the * received packet, and if so, store the options as ancillary @@ -1130,7 +1064,7 @@ ip6_savecontrol(in6p, mp, ip6, m) * Note that the order of the headers remains in * the chain of ancillary data. */ - while (1) { /* is explicit loop prevention necessary? */ + while(1) { /* is explicit loop prevention necessary? */ struct ip6_ext *ip6e; int elen; @@ -1158,50 +1092,50 @@ ip6_savecontrol(in6p, mp, ip6, m) } #endif - switch (nxt) { - case IPPROTO_DSTOPTS: - if (!in6p->in6p_flags & IN6P_DSTOPTS) - break; - - /* - * We also require super-user privilege for - * the option. - * See the comments on IN6_HOPOPTS. - */ - if (!privileged) - break; - - *mp = sbcreatecontrol((caddr_t)ip6e, elen, - IPV6_DSTOPTS, - IPPROTO_IPV6); - if (*mp) - mp = &(*mp)->m_next; - break; - - case IPPROTO_ROUTING: - if (!in6p->in6p_flags & IN6P_RTHDR) - break; - - *mp = sbcreatecontrol((caddr_t)ip6e, elen, - IPV6_RTHDR, - IPPROTO_IPV6); - if (*mp) - mp = &(*mp)->m_next; - break; - - case IPPROTO_UDP: - case IPPROTO_TCP: - case IPPROTO_ICMPV6: - default: - /* - * stop search if we encounter an upper - * layer protocol headers. - */ - goto loopend; - - case IPPROTO_HOPOPTS: - case IPPROTO_AH: /* is it possible? */ - break; + switch(nxt) { + case IPPROTO_DSTOPTS: + if (!in6p->in6p_flags & IN6P_DSTOPTS) + break; + + /* + * We also require super-user privilege for + * the option. + * See the comments on IN6_HOPOPTS. + */ + if (!privileged) + break; + + *mp = sbcreatecontrol((caddr_t)ip6e, elen, + IPV6_DSTOPTS, + IPPROTO_IPV6); + if (*mp) + mp = &(*mp)->m_next; + break; + + case IPPROTO_ROUTING: + if (!in6p->in6p_flags & IN6P_RTHDR) + break; + + *mp = sbcreatecontrol((caddr_t)ip6e, elen, + IPV6_RTHDR, + IPPROTO_IPV6); + if (*mp) + mp = &(*mp)->m_next; + break; + + case IPPROTO_UDP: + case IPPROTO_TCP: + case IPPROTO_ICMPV6: + default: + /* + * stop search if we encounter an upper + * layer protocol headers. + */ + goto loopend; + + case IPPROTO_HOPOPTS: + case IPPROTO_AH: /* is it possible? */ + break; } /* proceed with the next header. */ @@ -1209,7 +1143,6 @@ ip6_savecontrol(in6p, mp, ip6, m) nxt = ip6e->ip6e_nxt; } loopend: - ; } if ((in6p->in6p_flags & IN6P_HOPOPTS) && privileged) { /* to be done */ @@ -1219,6 +1152,12 @@ ip6_savecontrol(in6p, mp, ip6, m) } /* IN6P_RTHDR - to be done */ +#ifdef __bsdi__ +# undef sbcreatecontrol +#endif +#ifdef __OpenBSD__ +# undef in6p_flags +#endif } /* @@ -1251,7 +1190,7 @@ ip6_get_prevhdr(m, off) while (len < off) { ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + len); - switch (nxt) { + switch(nxt) { case IPPROTO_FRAGMENT: len += sizeof(struct ip6_frag); break; @@ -1272,115 +1211,6 @@ ip6_get_prevhdr(m, off) } /* - * get next header offset. m will be retained. - */ -int -ip6_nexthdr(m, off, proto, nxtp) - struct mbuf *m; - int off; - int proto; - int *nxtp; -{ - struct ip6_hdr ip6; - struct ip6_ext ip6e; - struct ip6_frag fh; - - /* just in case */ - if (m == NULL) - panic("ip6_nexthdr: m == NULL"); - if ((m->m_flags & M_PKTHDR) == 0 || m->m_pkthdr.len < off) - return -1; - - switch (proto) { - case IPPROTO_IPV6: - if (m->m_pkthdr.len < off + sizeof(ip6)) - return -1; - m_copydata(m, off, sizeof(ip6), (caddr_t)&ip6); - if (nxtp) - *nxtp = ip6.ip6_nxt; - off += sizeof(ip6); - return off; - - case IPPROTO_FRAGMENT: - /* - * terminate parsing if it is not the first fragment, - * it does not make sense to parse through it. - */ - 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) - return -1; - if (nxtp) - *nxtp = fh.ip6f_nxt; - off += sizeof(struct ip6_frag); - return off; - - case IPPROTO_AH: - if (m->m_pkthdr.len < off + sizeof(ip6e)) - return -1; - m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e); - if (nxtp) - *nxtp = ip6e.ip6e_nxt; - off += (ip6e.ip6e_len + 2) << 2; - return off; - - case IPPROTO_HOPOPTS: - case IPPROTO_ROUTING: - case IPPROTO_DSTOPTS: - if (m->m_pkthdr.len < off + sizeof(ip6e)) - return -1; - m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e); - if (nxtp) - *nxtp = ip6e.ip6e_nxt; - off += (ip6e.ip6e_len + 1) << 3; - return off; - - case IPPROTO_NONE: - case IPPROTO_ESP: - case IPPROTO_IPCOMP: - /* give up */ - return -1; - - default: - return -1; - } - - return -1; -} - -/* - * get offset for the last header in the chain. m will be kept untainted. - */ -int -ip6_lasthdr(m, off, proto, nxtp) - struct mbuf *m; - int off; - int proto; - int *nxtp; -{ - int newoff; - int nxt; - - if (!nxtp) { - nxt = -1; - nxtp = &nxt; - } - while (1) { - newoff = ip6_nexthdr(m, off, proto, nxtp); - if (newoff < 0) - return off; - else if (newoff < off) - return -1; /* invalid */ - else if (newoff == off) - return newoff; - - off = newoff; - proto = *nxtp; - } -} - -/* * System control for IP6 */ @@ -1393,7 +1223,8 @@ u_char inet6ctlerrmap[PRC_NCMDS] = { ENOPROTOOPT }; -#include +#if defined(__NetBSD__) || defined(__OpenBSD__) +#include #include int @@ -1405,8 +1236,6 @@ ip6_sysctl(name, namelen, oldp, oldlenp, void *newp; size_t newlen; { - int old, error; - /* All sysctl names at this level are terminal. */ if (namelen != 1) return ENOTDIR; @@ -1451,67 +1280,37 @@ ip6_sysctl(name, namelen, oldp, oldlenp, 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); -#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 -#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 -#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 */ } +#endif /* __NetBSD__ || __OpenBSD__ */ + +#ifdef __bsdi__ +int *ip6_sysvars[] = IPV6CTL_VARS; + +int +ip6_sysctl(name, namelen, oldp, oldlenp, newp, newlen) + int *name; + u_int namelen; + void *oldp; + size_t *oldlenp; + void *newp; + size_t newlen; +{ + if (name[0] >= IPV6CTL_MAXID) + return (EOPNOTSUPP); + + switch (name[0]) { + case IPV6CTL_STATS: + return sysctl_rdtrunc(oldp, oldlenp, newp, &ip6stat, + sizeof(ip6stat)); + case IPV6CTL_KAME_VERSION: + return sysctl_rdstring(oldp, oldlenp, newp, __KAME_VERSION); + default: + return (sysctl_int_arr(ip6_sysvars, name, namelen, + oldp, oldlenp, newp, newlen)); + } +} +#endif /* __bsdi__ */