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.77.12.2 retrieving revision 1.82.6.1 diff -u -p -r1.77.12.2 -r1.82.6.1 --- src/sys/netinet6/ip6_input.c 2007/04/26 06:55:37 1.77.12.2 +++ src/sys/netinet6/ip6_input.c 2006/03/13 09:07:39 1.82.6.1 @@ -1,4 +1,4 @@ -/* $NetBSD: ip6_input.c,v 1.77.12.2 2007/04/26 06:55:37 ghen Exp $ */ +/* $NetBSD: ip6_input.c,v 1.82.6.1 2006/03/13 09:07:39 yamt Exp $ */ /* $KAME: ip6_input.c,v 1.188 2001/03/29 05:34:31 itojun Exp $ */ /* @@ -62,7 +62,7 @@ */ #include -__KERNEL_RCSID(0, "$NetBSD: ip6_input.c,v 1.77.12.2 2007/04/26 06:55:37 ghen Exp $"); +__KERNEL_RCSID(0, "$NetBSD: ip6_input.c,v 1.82.6.1 2006/03/13 09:07:39 yamt Exp $"); #include "opt_inet.h" #include "opt_ipsec.h" @@ -103,6 +103,7 @@ __KERNEL_RCSID(0, "$NetBSD: ip6_input.c, #include #include #include +#include #include #include @@ -128,6 +129,8 @@ static int ip6qmaxlen = IFQ_MAXLEN; struct in6_ifaddr *in6_ifaddr; struct ifqueue ip6intrq; +extern struct callout in6_tmpaddrtimer_ch; + int ip6_forward_srcrt; /* XXX */ int ip6_sourcecheck; /* XXX */ int ip6_sourcecheck_interval; /* XXX */ @@ -139,6 +142,7 @@ struct pfil_head inet6_pfil_hook; struct ip6stat ip6stat; static void ip6_init2 __P((void *)); +static struct m_tag *ip6_setdstifaddr __P((struct mbuf *, struct in6_ifaddr *)); 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)); @@ -150,22 +154,25 @@ static struct mbuf *ip6_pullexthdr __P(( void ip6_init() { - struct ip6protosw *pr; + const struct ip6protosw *pr; int i; - pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW); + pr = (const struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW); if (pr == 0) panic("ip6_init"); for (i = 0; i < IPPROTO_MAX; i++) ip6_protox[i] = pr - inet6sw; - for (pr = (struct ip6protosw *)inet6domain.dom_protosw; - pr < (struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++) + for (pr = (const struct ip6protosw *)inet6domain.dom_protosw; + pr < (const struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++) if (pr->pr_domain->dom_family == PF_INET6 && pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW) ip6_protox[pr->pr_protocol] = pr - inet6sw; ip6intrq.ifq_maxlen = ip6qmaxlen; + scope6_init(); + addrsel_policy_init(); nd6_init(); frag6_init(); + ip6_desync_factor = arc4random() % MAX_TEMP_DESYNC_FACTOR; ip6_init2((void *)0); @@ -188,6 +195,13 @@ ip6_init2(dummy) /* nd6_timer_init */ callout_init(&nd6_timer_ch); callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL); + + /* timer for regeneranation of temporary addresses randomize ID */ + callout_init(&in6_tmpaddrtimer_ch); + callout_reset(&in6_tmpaddrtimer_ch, + (ip6_temp_preferred_lifetime - ip6_desync_factor - + ip6_temp_regen_advance) * hz, + in6_tmpaddrtimer, NULL); } /* @@ -205,6 +219,11 @@ ip6intr() splx(s); if (m == 0) return; + /* drop the packet if IPv6 operation is disabled on the IF */ + if ((ND_IFINFO(m->m_pkthdr.rcvif)->flags & ND6_IFF_IFDISABLED)) { + m_freem(m); + return; + } ip6_input(m); } } @@ -233,6 +252,11 @@ ip6_input(m) #endif /* + * make sure we don't have onion peering information into m_tag. + */ + ip6_delaux(m); + + /* * mbuf statistics */ if (m->m_flags & M_EXT) { @@ -260,7 +284,7 @@ ip6_input(m) /* * 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 + * 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) { @@ -375,61 +399,24 @@ ip6_input(m) } #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) { - ours = 1; - deliverifp = m->m_pkthdr.rcvif; - goto hbhcheck; - } else { - ip6stat.ip6s_badscope++; - in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr); - goto bad; - } - } - - /* 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; - } + /* + * Disambiguate address scope zones (if there is ambiguity). + * We first make sure that the original source or destination address + * is not in our internal form for scoped addresses. Such addresses + * are not necessarily invalid spec-wise, but we cannot accept them due + * to the usage conflict. + * in6_setscope() then also checks and rejects the cases where src or + * dst are the loopback address and the receiving interface + * is not loopback. + */ + if (in6_clearscope(&ip6->ip6_src) || in6_clearscope(&ip6->ip6_dst)) { + ip6stat.ip6s_badscope++; /* XXX */ + goto bad; } - - 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; + if (in6_setscope(&ip6->ip6_src, m->m_pkthdr.rcvif, NULL) || + in6_setscope(&ip6->ip6_dst, m->m_pkthdr.rcvif, NULL)) { + ip6stat.ip6s_badscope++; + goto bad; } /* @@ -583,6 +570,27 @@ ip6_input(m) hbhcheck: /* + * record address information into m_tag, if we don't have one yet. + * note that we are unable to record it, if the address is not listed + * as our interface address (e.g. multicast addresses, addresses + * within FAITH prefixes and such). + */ + if (deliverifp && !ip6_getdstifaddr(m)) { + struct in6_ifaddr *ia6; + + ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst); + if (ia6) { + if (!ip6_setdstifaddr(m, ia6)) { + /* + * XXX maybe we should drop the packet here, + * as we could not provide enough information + * to the upper layers. + */ + } + } + } + + /* * Process Hop-by-Hop options header if it's contained. * m may be modified in ip6_hopopts_input(). * If a JumboPayload option is included, plen will also be modified. @@ -609,7 +617,7 @@ ip6_input(m) if (ip6->ip6_plen == 0 && plen == 0) { /* * Note that if a valid jumbo payload option is - * contained, ip6_hoptops_input() must set a valid + * contained, ip6_hopopts_input() must set a valid * (non-zero) payload length to the variable plen. */ ip6stat.ip6s_badoptions++; @@ -753,6 +761,35 @@ ip6_input(m) } /* + * set/grab in6_ifaddr correspond to IPv6 destination address. + */ +static struct m_tag * +ip6_setdstifaddr(m, ia6) + struct mbuf *m; + struct in6_ifaddr *ia6; +{ + struct m_tag *mtag; + + mtag = ip6_addaux(m); + if (mtag) + ((struct ip6aux *)(mtag + 1))->ip6a_dstia6 = ia6; + return mtag; /* NULL if failed to set */ +} + +struct in6_ifaddr * +ip6_getdstifaddr(m) + struct mbuf *m; +{ + struct m_tag *mtag; + + mtag = ip6_findaux(m); + if (mtag) + return ((struct ip6aux *)(mtag + 1))->ip6a_dstia6; + else + return NULL; +} + +/* * Hop-by-Hop options header processing. If a valid jumbo payload option is * included, the real payload length will be stored in plenp. */ @@ -1005,11 +1042,6 @@ ip6_savecontrol(in6p, mp, ip6, m) mp = &(*mp)->m_next; } #endif - - /* some OSes call this logic with IPv4 packet, for SO_TIMESTAMP */ - if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) - return; - if (in6p->in6p_flags & IN6P_RECVDSTADDR) { *mp = sbcreatecontrol((caddr_t) &ip6->ip6_dst, sizeof(struct in6_addr), IPV6_RECVDSTADDR, IPPROTO_IPV6); @@ -1030,8 +1062,7 @@ ip6_savecontrol(in6p, mp, ip6, m) if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) { struct in6_pktinfo pi6; bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr)); - if (IN6_IS_SCOPE_LINKLOCAL(&pi6.ipi6_addr)) - pi6.ipi6_addr.s6_addr16[1] = 0; + in6_clearscope(&pi6.ipi6_addr); /* XXX */ pi6.ipi6_ifindex = (m && m->m_pkthdr.rcvif) ? m->m_pkthdr.rcvif->if_index : 0; @@ -1064,14 +1095,14 @@ ip6_savecontrol(in6p, mp, ip6, m) * just after the IPv6 header, which fact is assured through * the IPv6 input processing. */ - struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); - if (ip6->ip6_nxt == IPPROTO_HOPOPTS) { + struct ip6_hdr *xip6 = mtod(m, struct ip6_hdr *); + if (xip6->ip6_nxt == IPPROTO_HOPOPTS) { struct ip6_hbh *hbh; int hbhlen; struct mbuf *ext; ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr), - ip6->ip6_nxt); + xip6->ip6_nxt); if (ext == NULL) { ip6stat.ip6s_tooshort++; return; @@ -1100,8 +1131,8 @@ ip6_savecontrol(in6p, mp, ip6, m) /* 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); + struct ip6_hdr *xip6 = mtod(m, struct ip6_hdr *); + int nxt = xip6->ip6_nxt, off = sizeof(struct ip6_hdr); /* * Search for destination options headers or routing @@ -1321,6 +1352,9 @@ ip6_nexthdr(m, off, proto, nxtp) switch (proto) { case IPPROTO_IPV6: + /* do not chase beyond intermediate IPv6 headers */ + if (off != 0) + return -1; if (m->m_pkthdr.len < off + sizeof(ip6)) return -1; m_copydata(m, off, sizeof(ip6), (caddr_t)&ip6); @@ -1410,6 +1444,45 @@ ip6_lasthdr(m, off, proto, nxtp) } } +struct m_tag * +ip6_addaux(m) + struct mbuf *m; +{ + struct m_tag *mtag; + + mtag = m_tag_find(m, PACKET_TAG_INET6, NULL); + if (!mtag) { + mtag = m_tag_get(PACKET_TAG_INET6, sizeof(struct ip6aux), + M_NOWAIT); + if (mtag) { + m_tag_prepend(m, mtag); + bzero(mtag + 1, sizeof(struct ip6aux)); + } + } + return mtag; +} + +struct m_tag * +ip6_findaux(m) + struct mbuf *m; +{ + struct m_tag *mtag; + + mtag = m_tag_find(m, PACKET_TAG_INET6, NULL); + return mtag; +} + +void +ip6_delaux(m) + struct mbuf *m; +{ + struct m_tag *mtag; + + mtag = m_tag_find(m, PACKET_TAG_INET6, NULL); + if (mtag) + m_tag_delete(m, mtag); +} + /* * System control for IP6 */ @@ -1423,31 +1496,6 @@ u_char inet6ctlerrmap[PRC_NCMDS] = { ENOPROTOOPT }; -static int -sysctl_net_inet6_ip6_rht0(SYSCTLFN_ARGS) -{ - int error, tmp; - struct sysctlnode node; - - node = *rnode; - tmp = ip6_rht0; - node.sysctl_data = &tmp; - error = sysctl_lookup(SYSCTLFN_CALL(&node)); - if (error || newp == NULL) - return error; - - switch (tmp) { - case -1: /* disable processing */ - case 0: /* disable for host, enable for router */ - case 1: /* enable for all */ - break; - default: - return EINVAL; - } - ip6_rht0 = tmp; - return 0; -} - SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup") { @@ -1507,12 +1555,6 @@ SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, IPV6CTL_FORWSRCRT, CTL_EOL); sysctl_createv(clog, 0, NULL, NULL, CTLFLAG_PERMANENT|CTLFLAG_READWRITE, - CTLTYPE_STRUCT, "stats", NULL, - NULL, 0, &?, sizeof(?), - CTL_NET, PF_INET6, IPPROTO_IPV6, - IPV6CTL_STATS, CTL_EOL); - sysctl_createv(clog, 0, NULL, NULL, - CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_STRUCT, "mrtstats", NULL, NULL, 0, &?, sizeof(?), CTL_NET, PF_INET6, IPPROTO_IPV6, @@ -1610,7 +1652,7 @@ SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, CTLFLAG_PERMANENT, CTLTYPE_STRING, "kame_version", SYSCTL_DESCR("KAME Version"), - NULL, 0, __KAME_VERSION, 0, + NULL, 0, __UNCONST(__KAME_VERSION), 0, CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_KAME_VERSION, CTL_EOL); sysctl_createv(clog, 0, NULL, NULL, @@ -1672,16 +1714,51 @@ SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, #endif /* IPNOPRIVPORTS */ sysctl_createv(clog, 0, NULL, NULL, CTLFLAG_PERMANENT|CTLFLAG_READWRITE, + CTLTYPE_INT, "use_tempaddr", + SYSCTL_DESCR("Use temporary address"), + NULL, 0, &ip6_use_tempaddr, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + CTL_CREATE, CTL_EOL); + sysctl_createv(clog, 0, NULL, NULL, + CTLFLAG_PERMANENT|CTLFLAG_READWRITE, + CTLTYPE_INT, "temppltime", + SYSCTL_DESCR("preferred lifetime of a temporary address"), + NULL, 0, &ip6_temp_preferred_lifetime, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + CTL_CREATE, CTL_EOL); + sysctl_createv(clog, 0, NULL, NULL, + CTLFLAG_PERMANENT|CTLFLAG_READWRITE, + CTLTYPE_INT, "tempvltime", + SYSCTL_DESCR("valid lifetime of a temporary address"), + NULL, 0, &ip6_temp_valid_lifetime, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + CTL_CREATE, CTL_EOL); + sysctl_createv(clog, 0, NULL, NULL, + CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "maxfrags", SYSCTL_DESCR("Maximum fragments in reassembly queue"), NULL, 0, &ip6_maxfrags, 0, CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_MAXFRAGS, CTL_EOL); sysctl_createv(clog, 0, NULL, NULL, - CTLFLAG_PERMANENT|CTLFLAG_READWRITE, - CTLTYPE_INT, "rht0", - SYSCTL_DESCR("Processing of routing header type 0 (IPv6)"), - sysctl_net_inet6_ip6_rht0, 0, &ip6_rht0, 0, - CTL_NET, PF_INET6, IPPROTO_IPV6, - CTL_CREATE, CTL_EOL); + CTLFLAG_PERMANENT, + CTLTYPE_STRUCT, "stats", + SYSCTL_DESCR("IPv6 statistics"), + NULL, 0, &ip6stat, sizeof(ip6stat), + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_STATS, CTL_EOL); + sysctl_createv(clog, 0, NULL, NULL, + CTLFLAG_PERMANENT|CTLFLAG_READWRITE, + CTLTYPE_INT, "use_defaultzone", + SYSCTL_DESCR("Whether to use the default scope zones"), + NULL, 0, &ip6_use_defzone, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + IPV6CTL_USE_DEFAULTZONE, CTL_EOL); + sysctl_createv(clog, 0, NULL, NULL, + CTLFLAG_PERMANENT|CTLFLAG_READWRITE, + CTLTYPE_INT, "mcast_pmtu", + SYSCTL_DESCR("Enable pMTU discovery for multicast packet"), + NULL, 0, &ip6_mcast_pmtu, 0, + CTL_NET, PF_INET6, IPPROTO_IPV6, + CTL_CREATE, CTL_EOL); }