sys/netinet6/ip6_input.c

   1 /*      $FreeBSD: src/sys/netinet6/ip6_input.c,v 1.11.2.15 2003/01/24 05:11:35 sam Exp $        */
   2 /*      $DragonFly: src/sys/netinet6/ip6_input.c,v 1.18 2004/06/02 14:43:01 eirikn Exp $        */
   3 /*      $KAME: ip6_input.c,v 1.259 2002/01/21 04:58:09 jinmei Exp $     */
   4
   5 /*
   6  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the project nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * Copyright (c) 1982, 1986, 1988, 1993
  36  *      The Regents of the University of California.  All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  * 3. All advertising materials mentioning features or use of this software
  47  *    must display the following acknowledgement:
  48  *      This product includes software developed by the University of
  49  *      California, Berkeley and its contributors.
  50  * 4. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  *
  66  *      @(#)ip_input.c  8.2 (Berkeley) 1/4/94
  67  */
  68
  69 #include "opt_ip6fw.h"
  70 #include "opt_inet.h"
  71 #include "opt_inet6.h"
  72 #include "opt_ipsec.h"
  73 #include "opt_pfil_hooks.h"
  74
  75 #include <sys/param.h>
  76 #include <sys/systm.h>
  77 #include <sys/malloc.h>
  78 #include <sys/mbuf.h>
  79 #include <sys/domain.h>
  80 #include <sys/protosw.h>
  81 #include <sys/socket.h>
  82 #include <sys/socketvar.h>
  83 #include <sys/errno.h>
  84 #include <sys/time.h>
  85 #include <sys/kernel.h>
  86 #include <sys/syslog.h>
  87 #include <sys/proc.h>
  88
  89 #include <sys/thread2.h>
  90 #include <sys/msgport2.h>
  91
  92 #include <net/if.h>
  93 #include <net/if_types.h>
  94 #include <net/if_dl.h>
  95 #include <net/route.h>
  96 #include <net/netisr.h>
  97 #ifdef PFIL_HOOKS
  98 #include <net/pfil.h>
  99 #endif
 100
 101 #include <netinet/in.h>
 102 #include <netinet/in_systm.h>
 103 #ifdef INET
 104 #include <netinet/ip.h>
 105 #include <netinet/ip_icmp.h>
 106 #endif /* INET */
 107 #include <netinet/ip6.h>
 108 #include <netinet6/in6_var.h>
 109 #include <netinet6/ip6_var.h>
 110 #include <netinet/in_pcb.h>
 111 #include <netinet/icmp6.h>
 112 #include <netinet6/in6_ifattach.h>
 113 #include <netinet6/nd6.h>
 114 #include <netinet6/in6_prefix.h>
 115
 116 #ifdef IPSEC
 117 #include <netinet6/ipsec.h>
 118 #ifdef INET6
 119 #include <netinet6/ipsec6.h>
 120 #endif
 121 #endif
 122
 123 #ifdef FAST_IPSEC
 124 #include "ipsec.h"
 125 #include "ipsec6.h"
 126 #define IPSEC
 127 #endif /* FAST_IPSEC */
 128
 129 #include <net/ip6fw/ip6_fw.h>
 130
 131 #include <netinet6/ip6protosw.h>
 132
 133 /* we need it for NLOOP. */
 134 #include "use_loop.h"
 135
 136 #include <net/net_osdep.h>
 137
 138 extern struct domain inet6domain;
 139 extern struct ip6protosw inet6sw[];
 140
 141 u_char ip6_protox[IPPROTO_MAX];
 142 struct in6_ifaddr *in6_ifaddr;
 143
 144 extern struct callout in6_tmpaddrtimer_ch;
 145
 146 int ip6_forward_srcrt;                  /* XXX */
 147 int ip6_sourcecheck;                    /* XXX */
 148 int ip6_sourcecheck_interval;           /* XXX */
 149
 150 int ip6_ours_check_algorithm;
 151
 152 #ifdef PFIL_HOOKS
 153 struct pfil_head inet6_pfil_hook;
 154 #endif
 155
 156 /* firewall hooks */
 157 ip6_fw_chk_t *ip6_fw_chk_ptr;
 158 ip6_fw_ctl_t *ip6_fw_ctl_ptr;
 159 int ip6_fw_enable = 1;
 160
 161 struct ip6stat ip6stat;
 162
 163 static void ip6_init2 (void *);
 164 static struct ip6aux *ip6_setdstifaddr (struct mbuf *, struct in6_ifaddr *);
 165 static int ip6_hopopts_input (u_int32_t *, u_int32_t *, struct mbuf **, int *);
 166 static int ip6_input(struct netmsg *msg);
 167 #ifdef PULLDOWN_TEST
 168 static struct mbuf *ip6_pullexthdr (struct mbuf *, size_t, int);
 169 #endif
 170
 171 /*
 172  * IP6 initialization: fill in IP6 protocol switch table.
 173  * All protocols not implemented in kernel go to raw IP6 protocol handler.
 174  */
 175 void
 176 ip6_init(void)
 177 {
 178         struct ip6protosw *pr;
 179         int i;
 180         struct timeval tv;
 181
 182 #ifdef DIAGNOSTIC
 183         if (sizeof(struct protosw) != sizeof(struct ip6protosw))
 184                 panic("sizeof(protosw) != sizeof(ip6protosw)");
 185 #endif
 186         pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);
 187         if (pr == 0)
 188                 panic("ip6_init");
 189         for (i = 0; i < IPPROTO_MAX; i++)
 190                 ip6_protox[i] = pr - inet6sw;
 191         for (pr = (struct ip6protosw *)inet6domain.dom_protosw;
 192             pr < (struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++)
 193                 if (pr->pr_domain->dom_family == PF_INET6 &&
 194                     pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
 195                         ip6_protox[pr->pr_protocol] = pr - inet6sw;
 196
 197 #ifdef PFIL_HOOKS
 198         inet6_pfil_hook.ph_type = PFIL_TYPE_AF;
 199         inet6_pfil_hook.ph_af = AF_INET6;
 200         if ((i = pfil_head_register(&inet6_pfil_hook)) != 0)
 201                 printf("%s: WARNING: unable to register pfil hook, "
 202                         "error %d\n", __func__, i);
 203 #endif /* PFIL_HOOKS */
 204
 205         netisr_register(NETISR_IPV6, cpu0_portfn, ip6_input);
 206         nd6_init();
 207         frag6_init();
 208         /*
 209          * in many cases, random() here does NOT return random number
 210          * as initialization during bootstrap time occur in fixed order.
 211          */
 212         microtime(&tv);
 213         ip6_flow_seq = random() ^ tv.tv_usec;
 214         microtime(&tv);
 215         ip6_desync_factor = (random() ^ tv.tv_usec) % MAX_TEMP_DESYNC_FACTOR;
 216 }
 217
 218 static void
 219 ip6_init2(void *dummy)
 220 {
 221
 222         /*
 223          * to route local address of p2p link to loopback,
 224          * assign loopback address first.
 225          */
 226         in6_ifattach(&loif[0], NULL);
 227
 228         /* nd6_timer_init */
 229         callout_init(&nd6_timer_ch);
 230         callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL);
 231
 232         /* router renumbering prefix list maintenance */
 233         callout_init(&in6_rr_timer_ch);
 234         callout_reset(&in6_rr_timer_ch, hz, in6_rr_timer, NULL);
 235
 236         /* timer for regeneranation of temporary addresses randomize ID */
 237         callout_reset(&in6_tmpaddrtimer_ch,
 238                       (ip6_temp_preferred_lifetime - ip6_desync_factor -
 239                        ip6_temp_regen_advance) * hz,
 240                       in6_tmpaddrtimer, NULL);
 241 }
 242
 243 /* cheat */
 244 /* This must be after route_init(), which is now SI_ORDER_THIRD */
 245 SYSINIT(netinet6init2, SI_SUB_PROTO_DOMAIN, SI_ORDER_MIDDLE, ip6_init2, NULL);
 246
 247 extern struct   route_in6 ip6_forward_rt;
 248
 249 static
 250 int
 251 ip6_input(struct netmsg *msg)
 252 {
 253         struct mbuf *m = ((struct netmsg_packet *)msg)->nm_packet;
 254         struct ip6_hdr *ip6;
 255         int off = sizeof(struct ip6_hdr), nest;
 256         u_int32_t plen;
 257         u_int32_t rtalert = ~0;
 258         int nxt, ours = 0;
 259         struct ifnet *deliverifp = NULL;
 260 #ifdef PFIL_HOOKS
 261         struct in6_addr odst;
 262 #endif
 263         int srcrt = 0;
 264
 265 #ifdef IPSEC
 266         /*
 267          * should the inner packet be considered authentic?
 268          * see comment in ah4_input().
 269          */
 270         if (m) {
 271                 m->m_flags &= ~M_AUTHIPHDR;
 272                 m->m_flags &= ~M_AUTHIPDGM;
 273         }
 274 #endif
 275
 276         /*
 277          * make sure we don't have onion peering information into m_aux.
 278          */
 279         ip6_delaux(m);
 280
 281         /*
 282          * mbuf statistics
 283          */
 284         if (m->m_flags & M_EXT) {
 285                 if (m->m_next)
 286                         ip6stat.ip6s_mext2m++;
 287                 else
 288                         ip6stat.ip6s_mext1++;
 289         } else {
 290 #define M2MMAX  (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0]))
 291                 if (m->m_next) {
 292                         if (m->m_flags & M_LOOP) {
 293                                 ip6stat.ip6s_m2m[loif[0].if_index]++;   /* XXX */
 294                         } else if (m->m_pkthdr.rcvif->if_index < M2MMAX)
 295                                 ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++;
 296                         else
 297                                 ip6stat.ip6s_m2m[0]++;
 298                 } else
 299                         ip6stat.ip6s_m1++;
 300 #undef M2MMAX
 301         }
 302
 303         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_receive);
 304         ip6stat.ip6s_total++;
 305
 306 #ifndef PULLDOWN_TEST
 307         /*
 308          * L2 bridge code and some other code can return mbuf chain
 309          * that does not conform to KAME requirement.  too bad.
 310          * XXX: fails to join if interface MTU > MCLBYTES.  jumbogram?
 311          */
 312         if (m && m->m_next != NULL && m->m_pkthdr.len < MCLBYTES) {
 313                 struct mbuf *n;
 314
 315                 MGETHDR(n, MB_DONTWAIT, MT_HEADER);
 316                 if (n)
 317                         M_MOVE_PKTHDR(n, m);
 318                 if (n && n->m_pkthdr.len > MHLEN) {
 319                         MCLGET(n, MB_DONTWAIT);
 320                         if ((n->m_flags & M_EXT) == 0) {
 321                                 m_freem(n);
 322                                 n = NULL;
 323                         }
 324                 }
 325                 if (n == NULL)
 326                         goto bad;
 327
 328                 m_copydata(m, 0, n->m_pkthdr.len, mtod(n, caddr_t));
 329                 n->m_len = n->m_pkthdr.len;
 330                 m_freem(m);
 331                 m = n;
 332         }
 333         IP6_EXTHDR_CHECK(m, 0, sizeof(struct ip6_hdr), EASYNC);
 334 #endif
 335
 336         if (m->m_len < sizeof(struct ip6_hdr)) {
 337                 struct ifnet *inifp;
 338                 inifp = m->m_pkthdr.rcvif;
 339                 if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == 0) {
 340                         ip6stat.ip6s_toosmall++;
 341                         in6_ifstat_inc(inifp, ifs6_in_hdrerr);
 342                         goto bad2;
 343                 }
 344         }
 345
 346         ip6 = mtod(m, struct ip6_hdr *);
 347
 348         if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {
 349                 ip6stat.ip6s_badvers++;
 350                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);
 351                 goto bad;
 352         }
 353
 354 #ifdef PFIL_HOOKS
 355         /*
 356          * Run through list of hooks for input packets.
 357          *
 358          * NB: Beware of the destination address changing
 359          *     (e.g. by NAT rewriting). When this happens,
 360          *     tell ip6_forward to do the right thing.
 361          */
 362         if (pfil_has_hooks(&inet6_pfil_hook)) {
 363                 odst = ip6->ip6_dst;
 364                 if (pfil_run_hooks(&inet6_pfil_hook, &m,
 365                     m->m_pkthdr.rcvif, PFIL_IN)) {
 366                         goto bad2;
 367                 }
 368                 if (m == NULL)                  /* consumed by filter */
 369                         goto bad2;
 370                 ip6 = mtod(m, struct ip6_hdr *);
 371                 srcrt = !IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst);
 372         }
 373 #endif /* PFIL_HOOKS */
 374
 375         ip6stat.ip6s_nxthist[ip6->ip6_nxt]++;
 376
 377         /*
 378          * Check with the firewall...
 379          */
 380         if (ip6_fw_enable && ip6_fw_chk_ptr) {
 381                 u_short port = 0;
 382                 /* If ipfw says divert, we have to just drop packet */
 383                 /* use port as a dummy argument */
 384                 if ((*ip6_fw_chk_ptr)(&ip6, NULL, &port, &m)) {
 385                         m_freem(m);
 386                         m = NULL;
 387                 }
 388                 if (!m)
 389                         goto bad2;
 390         }
 391
 392         /*
 393          * Check against address spoofing/corruption.
 394          */
 395         if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src) ||
 396             IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_dst)) {
 397                 /*
 398                  * XXX: "badscope" is not very suitable for a multicast source.
 399                  */
 400                 ip6stat.ip6s_badscope++;
 401                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);
 402                 goto bad;
 403         }
 404         if ((IN6_IS_ADDR_LOOPBACK(&ip6->ip6_src) ||
 405              IN6_IS_ADDR_LOOPBACK(&ip6->ip6_dst)) &&
 406             (m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {
 407                 ip6stat.ip6s_badscope++;
 408                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);
 409                 goto bad;
 410         }
 411
 412         /*
 413          * The following check is not documented in specs.  A malicious
 414          * party may be able to use IPv4 mapped addr to confuse tcp/udp stack
 415          * and bypass security checks (act as if it was from 127.0.0.1 by using
 416          * IPv6 src ::ffff:127.0.0.1).  Be cautious.
 417          *
 418          * This check chokes if we are in an SIIT cloud.  As none of BSDs
 419          * support IPv4-less kernel compilation, we cannot support SIIT
 420          * environment at all.  So, it makes more sense for us to reject any
 421          * malicious packets for non-SIIT environment, than try to do a
 422          * partical support for SIIT environment.
 423          */
 424         if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
 425             IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
 426                 ip6stat.ip6s_badscope++;
 427                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);
 428                 goto bad;
 429         }
 430 #if 0
 431         /*
 432          * Reject packets with IPv4 compatible addresses (auto tunnel).
 433          *
 434          * The code forbids auto tunnel relay case in RFC1933 (the check is
 435          * stronger than RFC1933).  We may want to re-enable it if mech-xx
 436          * is revised to forbid relaying case.
 437          */
 438         if (IN6_IS_ADDR_V4COMPAT(&ip6->ip6_src) ||
 439             IN6_IS_ADDR_V4COMPAT(&ip6->ip6_dst)) {
 440                 ip6stat.ip6s_badscope++;
 441                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);
 442                 goto bad;
 443         }
 444 #endif
 445
 446         /* drop packets if interface ID portion is already filled */
 447         if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {
 448                 if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src) &&
 449                     ip6->ip6_src.s6_addr16[1]) {
 450                         ip6stat.ip6s_badscope++;
 451                         goto bad;
 452                 }
 453                 if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst) &&
 454                     ip6->ip6_dst.s6_addr16[1]) {
 455                         ip6stat.ip6s_badscope++;
 456                         goto bad;
 457                 }
 458         }
 459
 460         if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))
 461                 ip6->ip6_src.s6_addr16[1]
 462                         = htons(m->m_pkthdr.rcvif->if_index);
 463         if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst))
 464                 ip6->ip6_dst.s6_addr16[1]
 465                         = htons(m->m_pkthdr.rcvif->if_index);
 466
 467 #if 0 /* this case seems to be unnecessary. (jinmei, 20010401) */
 468         /*
 469          * We use rt->rt_ifp to determine if the address is ours or not.
 470          * If rt_ifp is lo0, the address is ours.
 471          * The problem here is, rt->rt_ifp for fe80::%lo0/64 is set to lo0,
 472          * so any address under fe80::%lo0/64 will be mistakenly considered
 473          * local.  The special case is supplied to handle the case properly
 474          * by actually looking at interface addresses
 475          * (using in6ifa_ifpwithaddr).
 476          */
 477         if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) != 0 &&
 478             IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_dst)) {
 479                 if (!in6ifa_ifpwithaddr(m->m_pkthdr.rcvif, &ip6->ip6_dst)) {
 480                         icmp6_error(m, ICMP6_DST_UNREACH,
 481                             ICMP6_DST_UNREACH_ADDR, 0);
 482                         /* m is already freed */
 483                         goto bad2;
 484                 }
 485
 486                 ours = 1;
 487                 deliverifp = m->m_pkthdr.rcvif;
 488                 goto hbhcheck;
 489         }
 490 #endif
 491
 492         /*
 493          * Multicast check
 494          */
 495         if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
 496                 struct  in6_multi *in6m = 0;
 497
 498                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_mcast);
 499                 /*
 500                  * See if we belong to the destination multicast group on the
 501                  * arrival interface.
 502                  */
 503                 IN6_LOOKUP_MULTI(ip6->ip6_dst, m->m_pkthdr.rcvif, in6m);
 504                 if (in6m)
 505                         ours = 1;
 506                 else if (!ip6_mrouter) {
 507                         ip6stat.ip6s_notmember++;
 508                         ip6stat.ip6s_cantforward++;
 509                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);
 510                         goto bad;
 511                 }
 512                 deliverifp = m->m_pkthdr.rcvif;
 513                 goto hbhcheck;
 514         }
 515
 516         /*
 517          *  Unicast check
 518          */
 519         switch (ip6_ours_check_algorithm) {
 520         default:
 521                 /*
 522                  * XXX: I intentionally broke our indentation rule here,
 523                  *      since this switch-case is just for measurement and
 524                  *      therefore should soon be removed.
 525                  */
 526         if (ip6_forward_rt.ro_rt != NULL &&
 527             (ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 &&
 528             IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,
 529                                &((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr))
 530                 ip6stat.ip6s_forward_cachehit++;
 531         else {
 532                 struct sockaddr_in6 *dst6;
 533
 534                 if (ip6_forward_rt.ro_rt) {
 535                         /* route is down or destination is different */
 536                         ip6stat.ip6s_forward_cachemiss++;
 537                         RTFREE(ip6_forward_rt.ro_rt);
 538                         ip6_forward_rt.ro_rt = 0;
 539                 }
 540
 541                 bzero(&ip6_forward_rt.ro_dst, sizeof(struct sockaddr_in6));
 542                 dst6 = (struct sockaddr_in6 *)&ip6_forward_rt.ro_dst;
 543                 dst6->sin6_len = sizeof(struct sockaddr_in6);
 544                 dst6->sin6_family = AF_INET6;
 545                 dst6->sin6_addr = ip6->ip6_dst;
 546 #ifdef SCOPEDROUTING
 547                 ip6_forward_rt.ro_dst.sin6_scope_id =
 548                         in6_addr2scopeid(m->m_pkthdr.rcvif, &ip6->ip6_dst);
 549 #endif
 550
 551                 rtalloc_ign((struct route *)&ip6_forward_rt, RTF_PRCLONING);
 552         }
 553
 554 #define rt6_key(r) ((struct sockaddr_in6 *)((r)->rt_nodes->rn_key))
 555
 556         /*
 557          * Accept the packet if the forwarding interface to the destination
 558          * according to the routing table is the loopback interface,
 559          * unless the associated route has a gateway.
 560          * Note that this approach causes to accept a packet if there is a
 561          * route to the loopback interface for the destination of the packet.
 562          * But we think it's even useful in some situations, e.g. when using
 563          * a special daemon which wants to intercept the packet.
 564          *
 565          * XXX: some OSes automatically make a cloned route for the destination
 566          * of an outgoing packet.  If the outgoing interface of the packet
 567          * is a loopback one, the kernel would consider the packet to be
 568          * accepted, even if we have no such address assinged on the interface.
 569          * We check the cloned flag of the route entry to reject such cases,
 570          * assuming that route entries for our own addresses are not made by
 571          * cloning (it should be true because in6_addloop explicitly installs
 572          * the host route).  However, we might have to do an explicit check
 573          * while it would be less efficient.  Or, should we rather install a
 574          * reject route for such a case?
 575          */
 576         if (ip6_forward_rt.ro_rt &&
 577             (ip6_forward_rt.ro_rt->rt_flags &
 578              (RTF_HOST|RTF_GATEWAY)) == RTF_HOST &&
 579 #ifdef RTF_WASCLONED
 580             !(ip6_forward_rt.ro_rt->rt_flags & RTF_WASCLONED) &&
 581 #endif
 582 #ifdef RTF_CLONED
 583             !(ip6_forward_rt.ro_rt->rt_flags & RTF_CLONED) &&
 584 #endif
 585 #if 0
 586             /*
 587              * The check below is redundant since the comparison of
 588              * the destination and the key of the rtentry has
 589              * already done through looking up the routing table.
 590              */
 591             IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,
 592                                 &rt6_key(ip6_forward_rt.ro_rt)->sin6_addr)
 593 #endif
 594             ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_LOOP) {
 595                 struct in6_ifaddr *ia6 =
 596                         (struct in6_ifaddr *)ip6_forward_rt.ro_rt->rt_ifa;
 597
 598                 /*
 599                  * record address information into m_aux.
 600                  */
 601                 (void)ip6_setdstifaddr(m, ia6);
 602
 603                 /*
 604                  * packets to a tentative, duplicated, or somehow invalid
 605                  * address must not be accepted.
 606                  */
 607                 if (!(ia6->ia6_flags & IN6_IFF_NOTREADY)) {
 608                         /* this address is ready */
 609                         ours = 1;
 610                         deliverifp = ia6->ia_ifp;       /* correct? */
 611                         /* Count the packet in the ip address stats */
 612                         ia6->ia_ifa.if_ipackets++;
 613                         ia6->ia_ifa.if_ibytes += m->m_pkthdr.len;
 614                         goto hbhcheck;
 615                 } else {
 616                         /* address is not ready, so discard the packet. */
 617                         nd6log((LOG_INFO,
 618                             "ip6_input: packet to an unready address %s->%s\n",
 619                             ip6_sprintf(&ip6->ip6_src),
 620                             ip6_sprintf(&ip6->ip6_dst)));
 621
 622                         goto bad;
 623                 }
 624         }
 625         } /* XXX indentation (see above) */
 626
 627         /*
 628          * FAITH(Firewall Aided Internet Translator)
 629          */
 630         if (ip6_keepfaith) {
 631                 if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp
 632                  && ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) {
 633                         /* XXX do we need more sanity checks? */
 634                         ours = 1;
 635                         deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */
 636                         goto hbhcheck;
 637                 }
 638         }
 639
 640         /*
 641          * Now there is no reason to process the packet if it's not our own
 642          * and we're not a router.
 643          */
 644         if (!ip6_forwarding) {
 645                 ip6stat.ip6s_cantforward++;
 646                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);
 647                 goto bad;
 648         }
 649
 650   hbhcheck:
 651         /*
 652          * record address information into m_aux, if we don't have one yet.
 653          * note that we are unable to record it, if the address is not listed
 654          * as our interface address (e.g. multicast addresses, addresses
 655          * within FAITH prefixes and such).
 656          */
 657         if (deliverifp && !ip6_getdstifaddr(m)) {
 658                 struct in6_ifaddr *ia6;
 659
 660                 ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst);
 661                 if (ia6) {
 662                         if (!ip6_setdstifaddr(m, ia6)) {
 663                                 /*
 664                                  * XXX maybe we should drop the packet here,
 665                                  * as we could not provide enough information
 666                                  * to the upper layers.
 667                                  */
 668                         }
 669                 }
 670         }
 671
 672         /*
 673          * Process Hop-by-Hop options header if it's contained.
 674          * m may be modified in ip6_hopopts_input().
 675          * If a JumboPayload option is included, plen will also be modified.
 676          */
 677         plen = (u_int32_t)ntohs(ip6->ip6_plen);
 678         if (ip6->ip6_nxt == IPPROTO_HOPOPTS) {
 679                 struct ip6_hbh *hbh;
 680
 681                 if (ip6_hopopts_input(&plen, &rtalert, &m, &off)) {
 682 #if 0   /*touches NULL pointer*/
 683                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);
 684 #endif
 685                         goto bad2;      /* m have already been freed */
 686                 }
 687
 688                 /* adjust pointer */
 689                 ip6 = mtod(m, struct ip6_hdr *);
 690
 691                 /*
 692                  * if the payload length field is 0 and the next header field
 693                  * indicates Hop-by-Hop Options header, then a Jumbo Payload
 694                  * option MUST be included.
 695                  */
 696                 if (ip6->ip6_plen == 0 && plen == 0) {
 697                         /*
 698                          * Note that if a valid jumbo payload option is
 699                          * contained, ip6_hoptops_input() must set a valid
 700                          * (non-zero) payload length to the variable plen.
 701                          */
 702                         ip6stat.ip6s_badoptions++;
 703                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);
 704                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);
 705                         icmp6_error(m, ICMP6_PARAM_PROB,
 706                                     ICMP6_PARAMPROB_HEADER,
 707                                     (caddr_t)&ip6->ip6_plen - (caddr_t)ip6);
 708                         goto bad2;
 709                 }
 710 #ifndef PULLDOWN_TEST
 711                 /* ip6_hopopts_input() ensures that mbuf is contiguous */
 712                 hbh = (struct ip6_hbh *)(ip6 + 1);
 713 #else
 714                 IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),
 715                         sizeof(struct ip6_hbh));
 716                 if (hbh == NULL) {
 717                         ip6stat.ip6s_tooshort++;
 718                         goto bad2;
 719                 }
 720 #endif
 721                 nxt = hbh->ip6h_nxt;
 722
 723                 /*
 724                  * accept the packet if a router alert option is included
 725                  * and we act as an IPv6 router.
 726                  */
 727                 if (rtalert != ~0 && ip6_forwarding)
 728                         ours = 1;
 729         } else
 730                 nxt = ip6->ip6_nxt;
 731
 732         /*
 733          * Check that the amount of data in the buffers
 734          * is as at least much as the IPv6 header would have us expect.
 735          * Trim mbufs if longer than we expect.
 736          * Drop packet if shorter than we expect.
 737          */
 738         if (m->m_pkthdr.len - sizeof(struct ip6_hdr) < plen) {
 739                 ip6stat.ip6s_tooshort++;
 740                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_truncated);
 741                 goto bad;
 742         }
 743         if (m->m_pkthdr.len > sizeof(struct ip6_hdr) + plen) {
 744                 if (m->m_len == m->m_pkthdr.len) {
 745                         m->m_len = sizeof(struct ip6_hdr) + plen;
 746                         m->m_pkthdr.len = sizeof(struct ip6_hdr) + plen;
 747                 } else
 748                         m_adj(m, sizeof(struct ip6_hdr) + plen - m->m_pkthdr.len);
 749         }
 750
 751         /*
 752          * Forward if desirable.
 753          */
 754         if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
 755                 /*
 756                  * If we are acting as a multicast router, all
 757                  * incoming multicast packets are passed to the
 758                  * kernel-level multicast forwarding function.
 759                  * The packet is returned (relatively) intact; if
 760                  * ip6_mforward() returns a non-zero value, the packet
 761                  * must be discarded, else it may be accepted below.
 762                  */
 763                 if (ip6_mrouter && ip6_mforward(ip6, m->m_pkthdr.rcvif, m)) {
 764                         ip6stat.ip6s_cantforward++;
 765                         goto bad;
 766                 }
 767                 if (!ours)
 768                         goto bad;
 769         } else if (!ours) {
 770                 ip6_forward(m, srcrt);
 771                 goto bad2;
 772         }
 773
 774         ip6 = mtod(m, struct ip6_hdr *);
 775
 776         /*
 777          * Malicious party may be able to use IPv4 mapped addr to confuse
 778          * tcp/udp stack and bypass security checks (act as if it was from
 779          * 127.0.0.1 by using IPv6 src ::ffff:127.0.0.1).  Be cautious.
 780          *
 781          * For SIIT end node behavior, you may want to disable the check.
 782          * However, you will  become vulnerable to attacks using IPv4 mapped
 783          * source.
 784          */
 785         if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
 786             IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
 787                 ip6stat.ip6s_badscope++;
 788                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);
 789                 goto bad;
 790         }
 791
 792         /*
 793          * Tell launch routine the next header
 794          */
 795         ip6stat.ip6s_delivered++;
 796         in6_ifstat_inc(deliverifp, ifs6_in_deliver);
 797         nest = 0;
 798
 799         while (nxt != IPPROTO_DONE) {
 800                 if (ip6_hdrnestlimit && (++nest > ip6_hdrnestlimit)) {
 801                         ip6stat.ip6s_toomanyhdr++;
 802                         goto bad;
 803                 }
 804
 805                 /*
 806                  * protection against faulty packet - there should be
 807                  * more sanity checks in header chain processing.
 808                  */
 809                 if (m->m_pkthdr.len < off) {
 810                         ip6stat.ip6s_tooshort++;
 811                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_truncated);
 812                         goto bad;
 813                 }
 814
 815 #if 0
 816                 /*
 817                  * do we need to do it for every header?  yeah, other
 818                  * functions can play with it (like re-allocate and copy).
 819                  */
 820                 mhist = ip6_addaux(m);
 821                 if (mhist && M_TRAILINGSPACE(mhist) >= sizeof(nxt)) {
 822                         hist = mtod(mhist, caddr_t) + mhist->m_len;
 823                         bcopy(&nxt, hist, sizeof(nxt));
 824                         mhist->m_len += sizeof(nxt);
 825                 } else {
 826                         ip6stat.ip6s_toomanyhdr++;
 827                         goto bad;
 828                 }
 829 #endif
 830
 831 #ifdef IPSEC
 832                 /*
 833                  * enforce IPsec policy checking if we are seeing last header.
 834                  * note that we do not visit this with protocols with pcb layer
 835                  * code - like udp/tcp/raw ip.
 836                  */
 837                 if ((inet6sw[ip6_protox[nxt]].pr_flags & PR_LASTHDR) != 0 &&
 838                     ipsec6_in_reject(m, NULL)) {
 839                         ipsec6stat.in_polvio++;
 840                         goto bad;
 841                 }
 842 #endif
 843
 844                 nxt = (*inet6sw[ip6_protox[nxt]].pr_input)(&m, &off, nxt);
 845         }
 846         goto bad2;
 847 bad:
 848         m_freem(m);
 849 bad2:
 850         lwkt_replymsg(&msg->nm_lmsg, 0);
 851         return(EASYNC);
 852 }
 853
 854 /*
 855  * set/grab in6_ifaddr correspond to IPv6 destination address.
 856  * XXX backward compatibility wrapper
 857  */
 858 static struct ip6aux *
 859 ip6_setdstifaddr(struct mbuf *m, struct in6_ifaddr *ia6)
 860 {
 861         struct ip6aux *n;
 862
 863         n = ip6_addaux(m);
 864         if (n)
 865                 n->ip6a_dstia6 = ia6;
 866         return n;       /* NULL if failed to set */
 867 }
 868
 869 struct in6_ifaddr *
 870 ip6_getdstifaddr(struct mbuf *m)
 871 {
 872         struct ip6aux *n;
 873
 874         n = ip6_findaux(m);
 875         if (n)
 876                 return n->ip6a_dstia6;
 877         else
 878                 return NULL;
 879 }
 880
 881 /*
 882  * Hop-by-Hop options header processing. If a valid jumbo payload option is
 883  * included, the real payload length will be stored in plenp.
 884  */
 885 static int
 886 ip6_hopopts_input(u_int32_t *plenp,
 887                   u_int32_t *rtalertp,/* XXX: should be stored more smart way */
 888                   struct mbuf **mp,
 889                   int *offp)
 890 {
 891         struct mbuf *m = *mp;
 892         int off = *offp, hbhlen;
 893         struct ip6_hbh *hbh;
 894         u_int8_t *opt;
 895
 896         /* validation of the length of the header */
 897 #ifndef PULLDOWN_TEST
 898         IP6_EXTHDR_CHECK(m, off, sizeof(*hbh), -1);
 899         hbh = (struct ip6_hbh *)(mtod(m, caddr_t) + off);
 900         hbhlen = (hbh->ip6h_len + 1) << 3;
 901
 902         IP6_EXTHDR_CHECK(m, off, hbhlen, -1);
 903         hbh = (struct ip6_hbh *)(mtod(m, caddr_t) + off);
 904 #else
 905         IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,
 906                 sizeof(struct ip6_hdr), sizeof(struct ip6_hbh));
 907         if (hbh == NULL) {
 908                 ip6stat.ip6s_tooshort++;
 909                 return -1;
 910         }
 911         hbhlen = (hbh->ip6h_len + 1) << 3;
 912         IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),
 913                 hbhlen);
 914         if (hbh == NULL) {
 915                 ip6stat.ip6s_tooshort++;
 916                 return -1;
 917         }
 918 #endif
 919         off += hbhlen;
 920         hbhlen -= sizeof(struct ip6_hbh);
 921         opt = (u_int8_t *)hbh + sizeof(struct ip6_hbh);
 922
 923         if (ip6_process_hopopts(m, (u_int8_t *)hbh + sizeof(struct ip6_hbh),
 924                                 hbhlen, rtalertp, plenp) < 0)
 925                 return(-1);
 926
 927         *offp = off;
 928         *mp = m;
 929         return(0);
 930 }
 931
 932 /*
 933  * Search header for all Hop-by-hop options and process each option.
 934  * This function is separate from ip6_hopopts_input() in order to
 935  * handle a case where the sending node itself process its hop-by-hop
 936  * options header. In such a case, the function is called from ip6_output().
 937  *
 938  * The function assumes that hbh header is located right after the IPv6 header
 939  * (RFC2460 p7), opthead is pointer into data content in m, and opthead to
 940  * opthead + hbhlen is located in continuous memory region.
 941  */
 942 int
 943 ip6_process_hopopts(struct mbuf *m, u_int8_t *opthead, int hbhlen,
 944                     u_int32_t *rtalertp, u_int32_t *plenp)
 945 {
 946         struct ip6_hdr *ip6;
 947         int optlen = 0;
 948         u_int8_t *opt = opthead;
 949         u_int16_t rtalert_val;
 950         u_int32_t jumboplen;
 951         const int erroff = sizeof(struct ip6_hdr) + sizeof(struct ip6_hbh);
 952
 953         for (; hbhlen > 0; hbhlen -= optlen, opt += optlen) {
 954                 switch (*opt) {
 955                 case IP6OPT_PAD1:
 956                         optlen = 1;
 957                         break;
 958                 case IP6OPT_PADN:
 959                         if (hbhlen < IP6OPT_MINLEN) {
 960                                 ip6stat.ip6s_toosmall++;
 961                                 goto bad;
 962                         }
 963                         optlen = *(opt + 1) + 2;
 964                         break;
 965                 case IP6OPT_RTALERT:
 966                         /* XXX may need check for alignment */
 967                         if (hbhlen < IP6OPT_RTALERT_LEN) {
 968                                 ip6stat.ip6s_toosmall++;
 969                                 goto bad;
 970                         }
 971                         if (*(opt + 1) != IP6OPT_RTALERT_LEN - 2) {
 972                                 /* XXX stat */
 973                                 icmp6_error(m, ICMP6_PARAM_PROB,
 974                                             ICMP6_PARAMPROB_HEADER,
 975                                             erroff + opt + 1 - opthead);
 976                                 return(-1);
 977                         }
 978                         optlen = IP6OPT_RTALERT_LEN;
 979                         bcopy((caddr_t)(opt + 2), (caddr_t)&rtalert_val, 2);
 980                         *rtalertp = ntohs(rtalert_val);
 981                         break;
 982                 case IP6OPT_JUMBO:
 983                         /* XXX may need check for alignment */
 984                         if (hbhlen < IP6OPT_JUMBO_LEN) {
 985                                 ip6stat.ip6s_toosmall++;
 986                                 goto bad;
 987                         }
 988                         if (*(opt + 1) != IP6OPT_JUMBO_LEN - 2) {
 989                                 /* XXX stat */
 990                                 icmp6_error(m, ICMP6_PARAM_PROB,
 991                                             ICMP6_PARAMPROB_HEADER,
 992                                             erroff + opt + 1 - opthead);
 993                                 return(-1);
 994                         }
 995                         optlen = IP6OPT_JUMBO_LEN;
 996
 997                         /*
 998                          * IPv6 packets that have non 0 payload length
 999                          * must not contain a jumbo payload option.
1000                          */
1001                         ip6 = mtod(m, struct ip6_hdr *);
1002                         if (ip6->ip6_plen) {
1003                                 ip6stat.ip6s_badoptions++;
1004                                 icmp6_error(m, ICMP6_PARAM_PROB,
1005                                             ICMP6_PARAMPROB_HEADER,
1006                                             erroff + opt - opthead);
1007                                 return(-1);
1008                         }
1009
1010                         /*
1011                          * We may see jumbolen in unaligned location, so
1012                          * we'd need to perform bcopy().
1013                          */
1014                         bcopy(opt + 2, &jumboplen, sizeof(jumboplen));
1015                         jumboplen = (u_int32_t)htonl(jumboplen);
1016
1017 #if 1
1018                         /*
1019                          * if there are multiple jumbo payload options,
1020                          * *plenp will be non-zero and the packet will be
1021                          * rejected.
1022                          * the behavior may need some debate in ipngwg -
1023                          * multiple options does not make sense, however,
1024                          * there's no explicit mention in specification.
1025                          */
1026                         if (*plenp != 0) {
1027                                 ip6stat.ip6s_badoptions++;
1028                                 icmp6_error(m, ICMP6_PARAM_PROB,
1029                                             ICMP6_PARAMPROB_HEADER,
1030                                             erroff + opt + 2 - opthead);
1031                                 return(-1);
1032                         }
1033 #endif
1034
1035                         /*
1036                          * jumbo payload length must be larger than 65535.
1037                          */
1038                         if (jumboplen <= IPV6_MAXPACKET) {
1039                                 ip6stat.ip6s_badoptions++;
1040                                 icmp6_error(m, ICMP6_PARAM_PROB,
1041                                             ICMP6_PARAMPROB_HEADER,
1042                                             erroff + opt + 2 - opthead);
1043                                 return(-1);
1044                         }
1045                         *plenp = jumboplen;
1046
1047                         break;
1048                 default:                /* unknown option */
1049                         if (hbhlen < IP6OPT_MINLEN) {
1050                                 ip6stat.ip6s_toosmall++;
1051                                 goto bad;
1052                         }
1053                         optlen = ip6_unknown_opt(opt, m,
1054                             erroff + opt - opthead);
1055                         if (optlen == -1)
1056                                 return(-1);
1057                         optlen += 2;
1058                         break;
1059                 }
1060         }
1061
1062         return(0);
1063
1064   bad:
1065         m_freem(m);
1066         return(-1);
1067 }
1068
1069 /*
1070  * Unknown option processing.
1071  * The third argument `off' is the offset from the IPv6 header to the option,
1072  * which is necessary if the IPv6 header the and option header and IPv6 header
1073  * is not continuous in order to return an ICMPv6 error.
1074  */
1075 int
1076 ip6_unknown_opt(u_int8_t *optp, struct mbuf *m, int off)
1077 {
1078         struct ip6_hdr *ip6;
1079
1080         switch (IP6OPT_TYPE(*optp)) {
1081         case IP6OPT_TYPE_SKIP: /* ignore the option */
1082                 return((int)*(optp + 1));
1083         case IP6OPT_TYPE_DISCARD:       /* silently discard */
1084                 m_freem(m);
1085                 return(-1);
1086         case IP6OPT_TYPE_FORCEICMP: /* send ICMP even if multicasted */
1087                 ip6stat.ip6s_badoptions++;
1088                 icmp6_error(m, ICMP6_PARAM_PROB, ICMP6_PARAMPROB_OPTION, off);
1089                 return(-1);
1090         case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */
1091                 ip6stat.ip6s_badoptions++;
1092                 ip6 = mtod(m, struct ip6_hdr *);
1093                 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) ||
1094                     (m->m_flags & (M_BCAST|M_MCAST)))
1095                         m_freem(m);
1096                 else
1097                         icmp6_error(m, ICMP6_PARAM_PROB,
1098                                     ICMP6_PARAMPROB_OPTION, off);
1099                 return(-1);
1100         }
1101
1102         m_freem(m);             /* XXX: NOTREACHED */
1103         return(-1);
1104 }
1105
1106 /*
1107  * Create the "control" list for this pcb.
1108  * The function will not modify mbuf chain at all.
1109  *
1110  * with KAME mbuf chain restriction:
1111  * The routine will be called from upper layer handlers like tcp6_input().
1112  * Thus the routine assumes that the caller (tcp6_input) have already
1113  * called IP6_EXTHDR_CHECK() and all the extension headers are located in the
1114  * very first mbuf on the mbuf chain.
1115  */
1116 void
1117 ip6_savecontrol(struct inpcb *in6p, struct mbuf **mp, struct ip6_hdr *ip6,
1118                 struct mbuf *m)
1119 {
1120         struct thread *td = curthread;  /* XXX */
1121         int privileged = 0;
1122         int rthdr_exist = 0;
1123
1124
1125         if (suser(td) == 0)
1126                 privileged++;
1127
1128 #ifdef SO_TIMESTAMP
1129         if ((in6p->in6p_socket->so_options & SO_TIMESTAMP) != 0) {
1130                 struct timeval tv;
1131
1132                 microtime(&tv);
1133                 *mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),
1134                                       SCM_TIMESTAMP, SOL_SOCKET);
1135                 if (*mp) {
1136                         mp = &(*mp)->m_next;
1137                 }
1138         }
1139 #endif
1140
1141         /* RFC 2292 sec. 5 */
1142         if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) {
1143                 struct in6_pktinfo pi6;
1144                 bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr));
1145                 if (IN6_IS_SCOPE_LINKLOCAL(&pi6.ipi6_addr))
1146                         pi6.ipi6_addr.s6_addr16[1] = 0;
1147                 pi6.ipi6_ifindex = (m && m->m_pkthdr.rcvif)
1148                                         ? m->m_pkthdr.rcvif->if_index
1149                                         : 0;
1150                 *mp = sbcreatecontrol((caddr_t) &pi6,
1151                         sizeof(struct in6_pktinfo), IPV6_PKTINFO,
1152                         IPPROTO_IPV6);
1153                 if (*mp)
1154                         mp = &(*mp)->m_next;
1155         }
1156
1157         if ((in6p->in6p_flags & IN6P_HOPLIMIT) != 0) {
1158                 int hlim = ip6->ip6_hlim & 0xff;
1159                 *mp = sbcreatecontrol((caddr_t) &hlim,
1160                         sizeof(int), IPV6_HOPLIMIT, IPPROTO_IPV6);
1161                 if (*mp)
1162                         mp = &(*mp)->m_next;
1163         }
1164
1165         /*
1166          * IPV6_HOPOPTS socket option. We require super-user privilege
1167          * for the option, but it might be too strict, since there might
1168          * be some hop-by-hop options which can be returned to normal user.
1169          * See RFC 2292 section 6.
1170          */
1171         if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0 && privileged) {
1172                 /*
1173                  * Check if a hop-by-hop options header is contatined in the
1174                  * received packet, and if so, store the options as ancillary
1175                  * data. Note that a hop-by-hop options header must be
1176                  * just after the IPv6 header, which fact is assured through
1177                  * the IPv6 input processing.
1178                  */
1179                 struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
1180                 if (ip6->ip6_nxt == IPPROTO_HOPOPTS) {
1181                         struct ip6_hbh *hbh;
1182                         int hbhlen = 0;
1183 #ifdef PULLDOWN_TEST
1184                         struct mbuf *ext;
1185 #endif
1186
1187 #ifndef PULLDOWN_TEST
1188                         hbh = (struct ip6_hbh *)(ip6 + 1);
1189                         hbhlen = (hbh->ip6h_len + 1) << 3;
1190 #else
1191                         ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr),
1192                             ip6->ip6_nxt);
1193                         if (ext == NULL) {
1194                                 ip6stat.ip6s_tooshort++;
1195                                 return;
1196                         }
1197                         hbh = mtod(ext, struct ip6_hbh *);
1198                         hbhlen = (hbh->ip6h_len + 1) << 3;
1199                         if (hbhlen != ext->m_len) {
1200                                 m_freem(ext);
1201                                 ip6stat.ip6s_tooshort++;
1202                                 return;
1203                         }
1204 #endif
1205
1206                         /*
1207                          * XXX: We copy whole the header even if a jumbo
1208                          * payload option is included, which option is to
1209                          * be removed before returning in the RFC 2292.
1210                          * Note: this constraint is removed in 2292bis.
1211                          */
1212                         *mp = sbcreatecontrol((caddr_t)hbh, hbhlen,
1213                                               IPV6_HOPOPTS, IPPROTO_IPV6);
1214                         if (*mp)
1215                                 mp = &(*mp)->m_next;
1216 #ifdef PULLDOWN_TEST
1217                         m_freem(ext);
1218 #endif
1219                 }
1220         }
1221
1222         /* IPV6_DSTOPTS and IPV6_RTHDR socket options */
1223         if ((in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDRDSTOPTS)) != 0) {
1224                 int proto, off, nxt;
1225
1226                 /*
1227                  * go through the header chain to see if a routing header is
1228                  * contained in the packet. We need this information to store
1229                  * destination options headers (if any) properly.
1230                  * XXX: performance issue. We should record this info when
1231                  * processing extension headers in incoming routine.
1232                  * (todo) use m_aux?
1233                  */
1234                 proto = IPPROTO_IPV6;
1235                 off = 0;
1236                 nxt = -1;
1237                 while (1) {
1238                         int newoff;
1239
1240                         newoff = ip6_nexthdr(m, off, proto, &nxt);
1241                         if (newoff < 0)
1242                                 break;
1243                         if (newoff < off) /* invalid, check for safety */
1244                                 break;
1245                         if ((proto = nxt) == IPPROTO_ROUTING) {
1246                                 rthdr_exist = 1;
1247                                 break;
1248                         }
1249                         off = newoff;
1250                 }
1251         }
1252
1253         if ((in6p->in6p_flags &
1254              (IN6P_RTHDR | IN6P_DSTOPTS | IN6P_RTHDRDSTOPTS)) != 0) {
1255                 struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
1256                 int nxt = ip6->ip6_nxt, off = sizeof(struct ip6_hdr);
1257
1258                 /*
1259                  * Search for destination options headers or routing
1260                  * header(s) through the header chain, and stores each
1261                  * header as ancillary data.
1262                  * Note that the order of the headers remains in
1263                  * the chain of ancillary data.
1264                  */
1265                 while (1) {     /* is explicit loop prevention necessary? */
1266                         struct ip6_ext *ip6e = NULL;
1267                         int elen;
1268 #ifdef PULLDOWN_TEST
1269                         struct mbuf *ext = NULL;
1270 #endif
1271
1272                         /*
1273                          * if it is not an extension header, don't try to
1274                          * pull it from the chain.
1275                          */
1276                         switch (nxt) {
1277                         case IPPROTO_DSTOPTS:
1278                         case IPPROTO_ROUTING:
1279                         case IPPROTO_HOPOPTS:
1280                         case IPPROTO_AH: /* is it possible? */
1281                                 break;
1282                         default:
1283                                 goto loopend;
1284                         }
1285
1286 #ifndef PULLDOWN_TEST
1287                         if (off + sizeof(*ip6e) > m->m_len)
1288                                 goto loopend;
1289                         ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + off);
1290                         if (nxt == IPPROTO_AH)
1291                                 elen = (ip6e->ip6e_len + 2) << 2;
1292                         else
1293                                 elen = (ip6e->ip6e_len + 1) << 3;
1294                         if (off + elen > m->m_len)
1295                                 goto loopend;
1296 #else
1297                         ext = ip6_pullexthdr(m, off, nxt);
1298                         if (ext == NULL) {
1299                                 ip6stat.ip6s_tooshort++;
1300                                 return;
1301                         }
1302                         ip6e = mtod(ext, struct ip6_ext *);
1303                         if (nxt == IPPROTO_AH)
1304                                 elen = (ip6e->ip6e_len + 2) << 2;
1305                         else
1306                                 elen = (ip6e->ip6e_len + 1) << 3;
1307                         if (elen != ext->m_len) {
1308                                 m_freem(ext);
1309                                 ip6stat.ip6s_tooshort++;
1310                                 return;
1311                         }
1312 #endif
1313
1314                         switch (nxt) {
1315                         case IPPROTO_DSTOPTS:
1316                                 if ((in6p->in6p_flags & IN6P_DSTOPTS) == 0)
1317                                         break;
1318
1319                                 /*
1320                                  * We also require super-user privilege for
1321                                  * the option.
1322                                  * See the comments on IN6_HOPOPTS.
1323                                  */
1324                                 if (!privileged)
1325                                         break;
1326
1327                                 *mp = sbcreatecontrol((caddr_t)ip6e, elen,
1328                                                       IPV6_DSTOPTS,
1329                                                       IPPROTO_IPV6);
1330                                 if (*mp)
1331                                         mp = &(*mp)->m_next;
1332                                 break;
1333                         case IPPROTO_ROUTING:
1334                                 if (!in6p->in6p_flags & IN6P_RTHDR)
1335                                         break;
1336
1337                                 *mp = sbcreatecontrol((caddr_t)ip6e, elen,
1338                                                       IPV6_RTHDR,
1339                                                       IPPROTO_IPV6);
1340                                 if (*mp)
1341                                         mp = &(*mp)->m_next;
1342                                 break;
1343                         case IPPROTO_HOPOPTS:
1344                         case IPPROTO_AH: /* is it possible? */
1345                                 break;
1346
1347                         default:
1348                                 /*
1349                                  * other cases have been filtered in the above.
1350                                  * none will visit this case.  here we supply
1351                                  * the code just in case (nxt overwritten or
1352                                  * other cases).
1353                                  */
1354 #ifdef PULLDOWN_TEST
1355                                 m_freem(ext);
1356 #endif
1357                                 goto loopend;
1358
1359                         }
1360
1361                         /* proceed with the next header. */
1362                         off += elen;
1363                         nxt = ip6e->ip6e_nxt;
1364                         ip6e = NULL;
1365 #ifdef PULLDOWN_TEST
1366                         m_freem(ext);
1367                         ext = NULL;
1368 #endif
1369                 }
1370           loopend:
1371                 ;
1372         }
1373
1374 }
1375
1376 #ifdef PULLDOWN_TEST
1377 /*
1378  * pull single extension header from mbuf chain.  returns single mbuf that
1379  * contains the result, or NULL on error.
1380  */
1381 static struct mbuf *
1382 ip6_pullexthdr(struct mbuf *m, size_t off, int nxt)
1383 {
1384         struct ip6_ext ip6e;
1385         size_t elen;
1386         struct mbuf *n;
1387
1388 #ifdef DIAGNOSTIC
1389         switch (nxt) {
1390         case IPPROTO_DSTOPTS:
1391         case IPPROTO_ROUTING:
1392         case IPPROTO_HOPOPTS:
1393         case IPPROTO_AH: /* is it possible? */
1394                 break;
1395         default:
1396                 printf("ip6_pullexthdr: invalid nxt=%d\n", nxt);
1397         }
1398 #endif
1399
1400         m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e);
1401         if (nxt == IPPROTO_AH)
1402                 elen = (ip6e.ip6e_len + 2) << 2;
1403         else
1404                 elen = (ip6e.ip6e_len + 1) << 3;
1405
1406         MGET(n, MB_DONTWAIT, MT_DATA);
1407         if (n && elen >= MLEN) {
1408                 MCLGET(n, MB_DONTWAIT);
1409                 if ((n->m_flags & M_EXT) == 0) {
1410                         m_free(n);
1411                         n = NULL;
1412                 }
1413         }
1414         if (!n)
1415                 return NULL;
1416
1417         n->m_len = 0;
1418         if (elen >= M_TRAILINGSPACE(n)) {
1419                 m_free(n);
1420                 return NULL;
1421         }
1422
1423         m_copydata(m, off, elen, mtod(n, caddr_t));
1424         n->m_len = elen;
1425         return n;
1426 }
1427 #endif
1428
1429 /*
1430  * Get pointer to the previous header followed by the header
1431  * currently processed.
1432  * XXX: This function supposes that
1433  *      M includes all headers,
1434  *      the next header field and the header length field of each header
1435  *      are valid, and
1436  *      the sum of each header length equals to OFF.
1437  * Because of these assumptions, this function must be called very
1438  * carefully. Moreover, it will not be used in the near future when
1439  * we develop `neater' mechanism to process extension headers.
1440  */
1441 char *
1442 ip6_get_prevhdr(struct mbuf *m, int off)
1443 {
1444         struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
1445
1446         if (off == sizeof(struct ip6_hdr))
1447                 return(&ip6->ip6_nxt);
1448         else {
1449                 int len, nxt;
1450                 struct ip6_ext *ip6e = NULL;
1451
1452                 nxt = ip6->ip6_nxt;
1453                 len = sizeof(struct ip6_hdr);
1454                 while (len < off) {
1455                         ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + len);
1456
1457                         switch (nxt) {
1458                         case IPPROTO_FRAGMENT:
1459                                 len += sizeof(struct ip6_frag);
1460                                 break;
1461                         case IPPROTO_AH:
1462                                 len += (ip6e->ip6e_len + 2) << 2;
1463                                 break;
1464                         default:
1465                                 len += (ip6e->ip6e_len + 1) << 3;
1466                                 break;
1467                         }
1468                         nxt = ip6e->ip6e_nxt;
1469                 }
1470                 if (ip6e)
1471                         return(&ip6e->ip6e_nxt);
1472                 else
1473                         return NULL;
1474         }
1475 }
1476
1477 /*
1478  * get next header offset.  m will be retained.
1479  */
1480 int
1481 ip6_nexthdr(struct mbuf *m, int off, int proto, int *nxtp)
1482 {
1483         struct ip6_hdr ip6;
1484         struct ip6_ext ip6e;
1485         struct ip6_frag fh;
1486
1487         /* just in case */
1488         if (m == NULL)
1489                 panic("ip6_nexthdr: m == NULL");
1490         if ((m->m_flags & M_PKTHDR) == 0 || m->m_pkthdr.len < off)
1491                 return -1;
1492
1493         switch (proto) {
1494         case IPPROTO_IPV6:
1495                 if (m->m_pkthdr.len < off + sizeof(ip6))
1496                         return -1;
1497                 m_copydata(m, off, sizeof(ip6), (caddr_t)&ip6);
1498                 if (nxtp)
1499                         *nxtp = ip6.ip6_nxt;
1500                 off += sizeof(ip6);
1501                 return off;
1502
1503         case IPPROTO_FRAGMENT:
1504                 /*
1505                  * terminate parsing if it is not the first fragment,
1506                  * it does not make sense to parse through it.
1507                  */
1508                 if (m->m_pkthdr.len < off + sizeof(fh))
1509                         return -1;
1510                 m_copydata(m, off, sizeof(fh), (caddr_t)&fh);
1511                 if ((ntohs(fh.ip6f_offlg) & IP6F_OFF_MASK) != 0)
1512                         return -1;
1513                 if (nxtp)
1514                         *nxtp = fh.ip6f_nxt;
1515                 off += sizeof(struct ip6_frag);
1516                 return off;
1517
1518         case IPPROTO_AH:
1519                 if (m->m_pkthdr.len < off + sizeof(ip6e))
1520                         return -1;
1521                 m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e);
1522                 if (nxtp)
1523                         *nxtp = ip6e.ip6e_nxt;
1524                 off += (ip6e.ip6e_len + 2) << 2;
1525                 return off;
1526
1527         case IPPROTO_HOPOPTS:
1528         case IPPROTO_ROUTING:
1529         case IPPROTO_DSTOPTS:
1530                 if (m->m_pkthdr.len < off + sizeof(ip6e))
1531                         return -1;
1532                 m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e);
1533                 if (nxtp)
1534                         *nxtp = ip6e.ip6e_nxt;
1535                 off += (ip6e.ip6e_len + 1) << 3;
1536                 return off;
1537
1538         case IPPROTO_NONE:
1539         case IPPROTO_ESP:
1540         case IPPROTO_IPCOMP:
1541                 /* give up */
1542                 return -1;
1543
1544         default:
1545                 return -1;
1546         }
1547
1548         return -1;
1549 }
1550
1551 /*
1552  * get offset for the last header in the chain.  m will be kept untainted.
1553  */
1554 int
1555 ip6_lasthdr(struct mbuf *m, int off, int proto, int *nxtp)
1556 {
1557         int newoff;
1558         int nxt;
1559
1560         if (!nxtp) {
1561                 nxt = -1;
1562                 nxtp = &nxt;
1563         }
1564         while (1) {
1565                 newoff = ip6_nexthdr(m, off, proto, nxtp);
1566                 if (newoff < 0)
1567                         return off;
1568                 else if (newoff < off)
1569                         return -1;      /* invalid */
1570                 else if (newoff == off)
1571                         return newoff;
1572
1573                 off = newoff;
1574                 proto = *nxtp;
1575         }
1576 }
1577
1578 struct ip6aux *
1579 ip6_addaux(struct mbuf *m)
1580 {
1581         struct m_tag *tag = m_tag_find(m, PACKET_TAG_IPV6_INPUT, NULL);
1582         if (!tag) {
1583                 tag = m_tag_get(PACKET_TAG_IPV6_INPUT,
1584                                 sizeof (struct ip6aux),
1585                                 MB_DONTWAIT);
1586                 if (tag)
1587                         m_tag_prepend(m, tag);
1588         }
1589         if (tag)
1590                 bzero(tag+1, sizeof (struct ip6aux));
1591         return tag ? (struct ip6aux*)(tag+1) : NULL;
1592 }
1593
1594 struct ip6aux *
1595 ip6_findaux(struct mbuf *m)
1596 {
1597         struct m_tag *tag = m_tag_find(m, PACKET_TAG_IPV6_INPUT, NULL);
1598         return tag ? (struct ip6aux*)(tag+1) : NULL;
1599 }
1600
1601 void
1602 ip6_delaux(struct mbuf *m)
1603 {
1604         struct m_tag *tag = m_tag_find(m, PACKET_TAG_IPV6_INPUT, NULL);
1605         if (tag)
1606                 m_tag_delete(m, tag);
1607 }
1608
1609 /*
1610  * System control for IP6
1611  */
1612
1613 u_char  inet6ctlerrmap[PRC_NCMDS] = {
1614         0,              0,              0,              0,
1615         0,              EMSGSIZE,       EHOSTDOWN,      EHOSTUNREACH,
1616         EHOSTUNREACH,   EHOSTUNREACH,   ECONNREFUSED,   ECONNREFUSED,
1617         EMSGSIZE,       EHOSTUNREACH,   0,              0,
1618         0,              0,              0,              0,
1619         ENOPROTOOPT
1620 };