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