[BACK]Return to ip6_input.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / netinet6

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/netinet6/ip6_input.c between version 1.113.8.2 and 1.164.2.3

version 1.113.8.2, 2008/03/24 07:16:24 version 1.164.2.3, 2017/01/07 08:56:51
Line 64 
Line 64 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
   #ifdef _KERNEL_OPT
   #include "opt_gateway.h"
 #include "opt_inet.h"  #include "opt_inet.h"
 #include "opt_inet6.h"  #include "opt_inet6.h"
 #include "opt_ipsec.h"  #include "opt_ipsec.h"
 #include "opt_pfil_hooks.h"  #include "opt_compat_netbsd.h"
   #include "opt_net_mpsafe.h"
   #endif
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
Line 83  __KERNEL_RCSID(0, "$NetBSD$");
Line 87  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/syslog.h>  #include <sys/syslog.h>
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   #include <sys/cprng.h>
   
 #include <net/if.h>  #include <net/if.h>
 #include <net/if_types.h>  #include <net/if_types.h>
 #include <net/if_dl.h>  #include <net/if_dl.h>
 #include <net/route.h>  #include <net/route.h>
 #include <net/netisr.h>  #include <net/pktqueue.h>
 #ifdef PFIL_HOOKS  
 #include <net/pfil.h>  #include <net/pfil.h>
 #endif  
   
 #include <netinet/in.h>  #include <netinet/in.h>
 #include <netinet/in_systm.h>  #include <netinet/in_systm.h>
 #ifdef INET  #ifdef INET
 #include <netinet/ip.h>  #include <netinet/ip.h>
   #include <netinet/ip_var.h>
 #include <netinet/ip_icmp.h>  #include <netinet/ip_icmp.h>
 #endif /* INET */  #endif /* INET */
 #include <netinet/ip6.h>  #include <netinet/ip6.h>
   #include <netinet/portalgo.h>
 #include <netinet6/in6_var.h>  #include <netinet6/in6_var.h>
 #include <netinet6/ip6_var.h>  #include <netinet6/ip6_var.h>
   #include <netinet6/ip6_private.h>
 #include <netinet6/in6_pcb.h>  #include <netinet6/in6_pcb.h>
 #include <netinet/icmp6.h>  #include <netinet/icmp6.h>
 #include <netinet6/scope6_var.h>  #include <netinet6/scope6_var.h>
Line 109  __KERNEL_RCSID(0, "$NetBSD$");
Line 115  __KERNEL_RCSID(0, "$NetBSD$");
 #include <netinet6/nd6.h>  #include <netinet6/nd6.h>
   
 #ifdef IPSEC  #ifdef IPSEC
 #include <netinet6/ipsec.h>  
 #endif  
   
 #ifdef FAST_IPSEC  
 #include <netipsec/ipsec.h>  #include <netipsec/ipsec.h>
 #include <netipsec/ipsec6.h>  #include <netipsec/ipsec6.h>
 #include <netipsec/key.h>  #include <netipsec/key.h>
 #endif /* FAST_IPSEC */  #endif /* IPSEC */
   
   #ifdef COMPAT_50
   #include <compat/sys/time.h>
   #include <compat/sys/socket.h>
   #endif
   
 #include <netinet6/ip6protosw.h>  #include <netinet6/ip6protosw.h>
   
 #include "faith.h"  #include "faith.h"
 #include "gif.h"  
   
 #if NGIF > 0  
 #include <netinet6/in6_gif.h>  
 #endif  
   
 #include <net/net_osdep.h>  #include <net/net_osdep.h>
   
 extern struct domain inet6domain;  extern struct domain inet6domain;
   
 u_char ip6_protox[IPPROTO_MAX];  u_char ip6_protox[IPPROTO_MAX];
 static int ip6qmaxlen = IFQ_MAXLEN;  pktqueue_t *ip6_pktq __read_mostly;
 struct in6_ifaddr *in6_ifaddr;  
 struct ifqueue ip6intrq;  
   
 extern callout_t in6_tmpaddrtimer_ch;  
   
 int ip6_forward_srcrt;                  /* XXX */  int ip6_forward_srcrt;                  /* XXX */
 int ip6_sourcecheck;                    /* XXX */  int ip6_sourcecheck;                    /* XXX */
 int ip6_sourcecheck_interval;           /* XXX */  int ip6_sourcecheck_interval;           /* XXX */
   
 #ifdef PFIL_HOOKS  pfil_head_t *inet6_pfil_hook;
 struct pfil_head inet6_pfil_hook;  
 #endif  
   
 struct ip6stat ip6stat;  percpu_t *ip6stat_percpu;
   
 static void ip6_init2(void *);  static void ip6_init2(void);
   static void ip6intr(void *);
 static struct m_tag *ip6_setdstifaddr(struct mbuf *, const struct in6_ifaddr *);  static struct m_tag *ip6_setdstifaddr(struct mbuf *, const struct in6_ifaddr *);
   
 static int ip6_hopopts_input(u_int32_t *, u_int32_t *, struct mbuf **, int *);  static int ip6_process_hopopts(struct mbuf *, u_int8_t *, int, u_int32_t *,
           u_int32_t *);
 static struct mbuf *ip6_pullexthdr(struct mbuf *, size_t, int);  static struct mbuf *ip6_pullexthdr(struct mbuf *, size_t, int);
   static void sysctl_net_inet6_ip6_setup(struct sysctllog **);
   
   #ifdef NET_MPSAFE
   #define SOFTNET_LOCK()          mutex_enter(softnet_lock)
   #define SOFTNET_UNLOCK()        mutex_exit(softnet_lock)
   #else
   #define SOFTNET_LOCK()          KASSERT(mutex_owned(softnet_lock))
   #define SOFTNET_UNLOCK()        KASSERT(mutex_owned(softnet_lock))
   #endif
   
 /*  /*
  * IP6 initialization: fill in IP6 protocol switch table.   * IP6 initialization: fill in IP6 protocol switch table.
Line 164  ip6_init(void)
Line 171  ip6_init(void)
         const struct ip6protosw *pr;          const struct ip6protosw *pr;
         int i;          int i;
   
           in6_init();
   
           sysctl_net_inet6_ip6_setup(NULL);
         pr = (const struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);          pr = (const struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);
         if (pr == 0)          if (pr == 0)
                 panic("ip6_init");                  panic("ip6_init");
Line 174  ip6_init(void)
Line 184  ip6_init(void)
                 if (pr->pr_domain->dom_family == PF_INET6 &&                  if (pr->pr_domain->dom_family == PF_INET6 &&
                     pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)                      pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
                         ip6_protox[pr->pr_protocol] = pr - inet6sw;                          ip6_protox[pr->pr_protocol] = pr - inet6sw;
         ip6intrq.ifq_maxlen = ip6qmaxlen;  
           ip6_pktq = pktq_create(IFQ_MAXLEN, ip6intr, NULL);
           KASSERT(ip6_pktq != NULL);
   
         scope6_init();          scope6_init();
         addrsel_policy_init();          addrsel_policy_init();
         nd6_init();          nd6_init();
         frag6_init();          frag6_init();
         ip6_desync_factor = arc4random() % MAX_TEMP_DESYNC_FACTOR;          ip6_desync_factor = cprng_fast32() % MAX_TEMP_DESYNC_FACTOR;
   
         ip6_init2((void *)0);          ip6_init2();
 #ifdef GATEWAY  #ifdef GATEWAY
         ip6flow_init(ip6_hashsize);          ip6flow_init(ip6_hashsize);
 #endif  #endif
   
 #ifdef PFIL_HOOKS  
         /* Register our Packet Filter hook. */          /* Register our Packet Filter hook. */
         inet6_pfil_hook.ph_type = PFIL_TYPE_AF;          inet6_pfil_hook = pfil_head_create(PFIL_TYPE_AF, (void *)AF_INET6);
         inet6_pfil_hook.ph_af   = AF_INET6;          KASSERT(inet6_pfil_hook != NULL);
         i = pfil_head_register(&inet6_pfil_hook);  
         if (i != 0)          ip6stat_percpu = percpu_alloc(sizeof(uint64_t) * IP6_NSTATS);
                 printf("ip6_init: WARNING: unable to register pfil hook, "  
                     "error %d\n", i);  
 #endif /* PFIL_HOOKS */  
 }  }
   
 static void  static void
 ip6_init2(void *dummy)  ip6_init2(void)
 {  {
   
         /* nd6_timer_init */  
         callout_init(&nd6_timer_ch, 0);  
         callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL);  
   
         /* timer for regeneranation of temporary addresses randomize ID */          /* timer for regeneranation of temporary addresses randomize ID */
         callout_init(&in6_tmpaddrtimer_ch, 0);          callout_init(&in6_tmpaddrtimer_ch, CALLOUT_MPSAFE);
         callout_reset(&in6_tmpaddrtimer_ch,          callout_reset(&in6_tmpaddrtimer_ch,
                       (ip6_temp_preferred_lifetime - ip6_desync_factor -                        (ip6_temp_preferred_lifetime - ip6_desync_factor -
                        ip6_temp_regen_advance) * hz,                         ip6_temp_regen_advance) * hz,
Line 216  ip6_init2(void *dummy)
Line 220  ip6_init2(void *dummy)
 /*  /*
  * IP6 input interrupt handling. Just pass the packet to ip6_input.   * IP6 input interrupt handling. Just pass the packet to ip6_input.
  */   */
 void  static void
 ip6intr(void)  ip6intr(void *arg __unused)
 {  {
         int s;  
         struct mbuf *m;          struct mbuf *m;
   
         for (;;) {  #ifndef NET_MPSAFE
                 s = splnet();          mutex_enter(softnet_lock);
                 IF_DEQUEUE(&ip6intrq, m);  #endif
                 splx(s);          while ((m = pktq_dequeue(ip6_pktq)) != NULL) {
                 if (m == 0)                  struct psref psref;
                         return;                  struct ifnet *rcvif = m_get_rcvif_psref(m, &psref);
                 /* drop the packet if IPv6 operation is disabled on the IF */  
                 if ((ND_IFINFO(m->m_pkthdr.rcvif)->flags & ND6_IFF_IFDISABLED)) {                  if (rcvif == NULL) {
                         m_freem(m);                          m_freem(m);
                         return;                          continue;
                 }                  }
                 ip6_input(m);                  /*
                    * Drop the packet if IPv6 is disabled on the interface.
                    */
                   if ((ND_IFINFO(rcvif)->flags & ND6_IFF_IFDISABLED)) {
                           m_put_rcvif_psref(rcvif, &psref);
                           m_freem(m);
                           continue;
                   }
                   ip6_input(m, rcvif);
                   m_put_rcvif_psref(rcvif, &psref);
         }          }
   #ifndef NET_MPSAFE
           mutex_exit(softnet_lock);
   #endif
 }  }
   
 extern struct   route ip6_forward_rt;  extern struct   route ip6_forward_rt;
   
 void  void
 ip6_input(struct mbuf *m)  ip6_input(struct mbuf *m, struct ifnet *rcvif)
 {  {
         struct ip6_hdr *ip6;          struct ip6_hdr *ip6;
         int hit, off = sizeof(struct ip6_hdr), nest;          int hit, off = sizeof(struct ip6_hdr), nest;
Line 249  ip6_input(struct mbuf *m)
Line 264  ip6_input(struct mbuf *m)
         int nxt, ours = 0, rh_present = 0;          int nxt, ours = 0, rh_present = 0;
         struct ifnet *deliverifp = NULL;          struct ifnet *deliverifp = NULL;
         int srcrt = 0;          int srcrt = 0;
         const struct rtentry *rt;          struct rtentry *rt = NULL;
         union {          union {
                 struct sockaddr         dst;                  struct sockaddr         dst;
                 struct sockaddr_in6     dst6;                  struct sockaddr_in6     dst6;
         } u;          } u;
 #ifdef FAST_IPSEC  
         struct m_tag *mtag;  
         struct tdb_ident *tdbi;  
         struct secpolicy *sp;  
         int s, error;  
 #endif  
   
 #ifdef IPSEC  
         /*  
          * should the inner packet be considered authentic?  
          * see comment in ah4_input().  
          */  
         m->m_flags &= ~M_AUTHIPHDR;  
         m->m_flags &= ~M_AUTHIPDGM;  
 #endif  
   
         /*          /*
          * make sure we don't have onion peering information into m_tag.           * make sure we don't have onion peering information into m_tag.
Line 280  ip6_input(struct mbuf *m)
Line 280  ip6_input(struct mbuf *m)
          */           */
         if (m->m_flags & M_EXT) {          if (m->m_flags & M_EXT) {
                 if (m->m_next)                  if (m->m_next)
                         ip6stat.ip6s_mext2m++;                          IP6_STATINC(IP6_STAT_MEXT2M);
                 else                  else
                         ip6stat.ip6s_mext1++;                          IP6_STATINC(IP6_STAT_MEXT1);
         } else {          } else {
 #define M2MMAX  __arraycount(ip6stat.ip6s_m2m)  #define M2MMAX  32
                 if (m->m_next) {                  if (m->m_next) {
                         if (m->m_flags & M_LOOP) {                          if (m->m_flags & M_LOOP)
                                 ip6stat.ip6s_m2m[lo0ifp->if_index]++; /* XXX */                          /*XXX*/ IP6_STATINC(IP6_STAT_M2M + lo0ifp->if_index);
                         } else if (m->m_pkthdr.rcvif->if_index < M2MMAX)                          else if (rcvif->if_index < M2MMAX)
                                 ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++;                                  IP6_STATINC(IP6_STAT_M2M + rcvif->if_index);
                         else                          else
                                 ip6stat.ip6s_m2m[0]++;                                  IP6_STATINC(IP6_STAT_M2M);
                 } else                  } else
                         ip6stat.ip6s_m1++;                          IP6_STATINC(IP6_STAT_M1);
 #undef M2MMAX  #undef M2MMAX
         }          }
   
         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_receive);          in6_ifstat_inc(rcvif, ifs6_in_receive);
         ip6stat.ip6s_total++;          IP6_STATINC(IP6_STAT_TOTAL);
   
         /*          /*
          * If the IPv6 header is not aligned, slurp it up into a new           * If the IPv6 header is not aligned, slurp it up into a new
Line 307  ip6_input(struct mbuf *m)
Line 307  ip6_input(struct mbuf *m)
          * IPv6 header is in the first mbuf of the chain.           * IPv6 header is in the first mbuf of the chain.
          */           */
         if (IP6_HDR_ALIGNED_P(mtod(m, void *)) == 0) {          if (IP6_HDR_ALIGNED_P(mtod(m, void *)) == 0) {
                 struct ifnet *inifp = m->m_pkthdr.rcvif;  
                 if ((m = m_copyup(m, sizeof(struct ip6_hdr),                  if ((m = m_copyup(m, sizeof(struct ip6_hdr),
                                   (max_linkhdr + 3) & ~3)) == NULL) {                                    (max_linkhdr + 3) & ~3)) == NULL) {
                         /* XXXJRT new stat, please */                          /* XXXJRT new stat, please */
                         ip6stat.ip6s_toosmall++;                          IP6_STATINC(IP6_STAT_TOOSMALL);
                         in6_ifstat_inc(inifp, ifs6_in_hdrerr);                          in6_ifstat_inc(rcvif, ifs6_in_hdrerr);
                         return;                          return;
                 }                  }
         } else if (__predict_false(m->m_len < sizeof(struct ip6_hdr))) {          } else if (__predict_false(m->m_len < sizeof(struct ip6_hdr))) {
                 struct ifnet *inifp = m->m_pkthdr.rcvif;  
                 if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == NULL) {                  if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == NULL) {
                         ip6stat.ip6s_toosmall++;                          IP6_STATINC(IP6_STAT_TOOSMALL);
                         in6_ifstat_inc(inifp, ifs6_in_hdrerr);                          in6_ifstat_inc(rcvif, ifs6_in_hdrerr);
                         return;                          return;
                 }                  }
         }          }
Line 327  ip6_input(struct mbuf *m)
Line 325  ip6_input(struct mbuf *m)
         ip6 = mtod(m, struct ip6_hdr *);          ip6 = mtod(m, struct ip6_hdr *);
   
         if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {          if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {
                 ip6stat.ip6s_badvers++;                  IP6_STATINC(IP6_STAT_BADVERS);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);                  in6_ifstat_inc(rcvif, ifs6_in_hdrerr);
                 goto bad;                  goto bad;
         }          }
   
 #if defined(IPSEC)  
         /* IPv6 fast forwarding is not compatible with IPsec. */  
         m->m_flags &= ~M_CANFASTFWD;  
 #else  
         /*          /*
          * Assume that we can create a fast-forward IP flow entry           * Assume that we can create a fast-forward IP flow entry
          * based on this packet.           * based on this packet.
          */           */
         m->m_flags |= M_CANFASTFWD;          m->m_flags |= M_CANFASTFWD;
 #endif  
   
 #ifdef PFIL_HOOKS  
         /*          /*
          * Run through list of hooks for input packets.  If there are any           * Run through list of hooks for input packets.  If there are any
          * filters which require that additional packets in the flow are           * filters which require that additional packets in the flow are
Line 355  ip6_input(struct mbuf *m)
Line 347  ip6_input(struct mbuf *m)
          * let ipfilter look at packet on the wire,           * let ipfilter look at packet on the wire,
          * not the decapsulated packet.           * not the decapsulated packet.
          */           */
 #ifdef IPSEC  #if defined(IPSEC)
         if (!ipsec_getnhist(m))          if (!ipsec_used || !ipsec_indone(m))
 #elif defined(FAST_IPSEC)  
         if (!ipsec_indone(m))  
 #else  #else
         if (1)          if (1)
 #endif  #endif
Line 366  ip6_input(struct mbuf *m)
Line 356  ip6_input(struct mbuf *m)
                 struct in6_addr odst;                  struct in6_addr odst;
   
                 odst = ip6->ip6_dst;                  odst = ip6->ip6_dst;
                 if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.rcvif,                  if (pfil_run_hooks(inet6_pfil_hook, &m, rcvif, PFIL_IN) != 0)
                                    PFIL_IN) != 0)  
                         return;                          return;
                 if (m == NULL)                  if (m == NULL)
                         return;                          return;
                 ip6 = mtod(m, struct ip6_hdr *);                  ip6 = mtod(m, struct ip6_hdr *);
                 srcrt = !IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst);                  srcrt = !IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst);
         }          }
 #endif /* PFIL_HOOKS */  
   
         ip6stat.ip6s_nxthist[ip6->ip6_nxt]++;          IP6_STATINC(IP6_STAT_NXTHIST + ip6->ip6_nxt);
   
 #ifdef ALTQ  #ifdef ALTQ
         if (altq_input != NULL && (*altq_input)(m, AF_INET6) == 0) {          if (altq_input != NULL) {
                 /* packet is dropped by traffic conditioner */                  SOFTNET_LOCK();
                 return;                  if ((*altq_input)(m, AF_INET6) == 0) {
                           SOFTNET_UNLOCK();
                           /* packet is dropped by traffic conditioner */
                           return;
                   }
                   SOFTNET_UNLOCK();
         }          }
 #endif  #endif
   
Line 393  ip6_input(struct mbuf *m)
Line 386  ip6_input(struct mbuf *m)
                 /*                  /*
                  * XXX: "badscope" is not very suitable for a multicast source.                   * XXX: "badscope" is not very suitable for a multicast source.
                  */                   */
                 ip6stat.ip6s_badscope++;                  IP6_STATINC(IP6_STAT_BADSCOPE);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);                  in6_ifstat_inc(rcvif, ifs6_in_addrerr);
                 goto bad;                  goto bad;
         }          }
         /*          /*
Line 411  ip6_input(struct mbuf *m)
Line 404  ip6_input(struct mbuf *m)
          */           */
         if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||          if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
             IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {              IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
                 ip6stat.ip6s_badscope++;                  IP6_STATINC(IP6_STAT_BADSCOPE);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);                  in6_ifstat_inc(rcvif, ifs6_in_addrerr);
                 goto bad;                  goto bad;
         }          }
 #if 0  #if 0
Line 425  ip6_input(struct mbuf *m)
Line 418  ip6_input(struct mbuf *m)
          */           */
         if (IN6_IS_ADDR_V4COMPAT(&ip6->ip6_src) ||          if (IN6_IS_ADDR_V4COMPAT(&ip6->ip6_src) ||
             IN6_IS_ADDR_V4COMPAT(&ip6->ip6_dst)) {              IN6_IS_ADDR_V4COMPAT(&ip6->ip6_dst)) {
                 ip6stat.ip6s_badscope++;                  IP6_STATINC(IP6_STAT_BADSCOPE);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);                  in6_ifstat_inc(rcvif, ifs6_in_addrerr);
                 goto bad;                  goto bad;
         }          }
 #endif  #endif
Line 446  ip6_input(struct mbuf *m)
Line 439  ip6_input(struct mbuf *m)
                 goto bad;                  goto bad;
         ip6 = mtod(m, struct ip6_hdr *);          ip6 = mtod(m, struct ip6_hdr *);
         if (in6_clearscope(&ip6->ip6_src) || in6_clearscope(&ip6->ip6_dst)) {          if (in6_clearscope(&ip6->ip6_src) || in6_clearscope(&ip6->ip6_dst)) {
                 ip6stat.ip6s_badscope++; /* XXX */                  IP6_STATINC(IP6_STAT_BADSCOPE); /* XXX */
                 goto bad;                  goto bad;
         }          }
         if (in6_setscope(&ip6->ip6_src, m->m_pkthdr.rcvif, NULL) ||          if (in6_setscope(&ip6->ip6_src, rcvif, NULL) ||
             in6_setscope(&ip6->ip6_dst, m->m_pkthdr.rcvif, NULL)) {              in6_setscope(&ip6->ip6_dst, rcvif, NULL)) {
                 ip6stat.ip6s_badscope++;                  IP6_STATINC(IP6_STAT_BADSCOPE);
                 goto bad;                  goto bad;
         }          }
   
           ro = percpu_getref(ip6_forward_rt_percpu);
         /*          /*
          * Multicast check           * Multicast check
          */           */
         if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {          if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
                 struct  in6_multi *in6m = 0;                  struct  in6_multi *in6m = 0;
   
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_mcast);                  in6_ifstat_inc(rcvif, ifs6_in_mcast);
                 /*                  /*
                  * See if we belong to the destination multicast group on the                   * See if we belong to the destination multicast group on the
                  * arrival interface.                   * arrival interface.
                  */                   */
                 IN6_LOOKUP_MULTI(ip6->ip6_dst, m->m_pkthdr.rcvif, in6m);                  IN6_LOOKUP_MULTI(ip6->ip6_dst, rcvif, in6m);
                 if (in6m)                  if (in6m)
                         ours = 1;                          ours = 1;
                 else if (!ip6_mrouter) {                  else if (!ip6_mrouter) {
                         ip6stat.ip6s_notmember++;                          uint64_t *ip6s = IP6_STAT_GETREF();
                         ip6stat.ip6s_cantforward++;                          ip6s[IP6_STAT_NOTMEMBER]++;
                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);                          ip6s[IP6_STAT_CANTFORWARD]++;
                         goto bad;                          IP6_STAT_PUTREF();
                           in6_ifstat_inc(rcvif, ifs6_in_discard);
                           goto bad_unref;
                 }                  }
                 deliverifp = m->m_pkthdr.rcvif;                  deliverifp = rcvif;
                 goto hbhcheck;                  goto hbhcheck;
         }          }
   
Line 484  ip6_input(struct mbuf *m)
Line 480  ip6_input(struct mbuf *m)
         /*          /*
          *  Unicast check           *  Unicast check
          */           */
         rt = rtcache_lookup2(&ip6_forward_rt, &u.dst, 1, &hit);          rt = rtcache_lookup2(ro, &u.dst, 1, &hit);
         if (hit)          if (hit)
                 ip6stat.ip6s_forward_cachehit++;                  IP6_STATINC(IP6_STAT_FORWARD_CACHEHIT);
         else          else
                 ip6stat.ip6s_forward_cachemiss++;                  IP6_STATINC(IP6_STAT_FORWARD_CACHEMISS);
   
 #define rt6_getkey(__rt) satocsin6(rt_getkey(__rt))  #define rt6_getkey(__rt) satocsin6(rt_getkey(__rt))
   
Line 503  ip6_input(struct mbuf *m)
Line 499  ip6_input(struct mbuf *m)
          */           */
         if (rt != NULL &&          if (rt != NULL &&
             (rt->rt_flags & (RTF_HOST|RTF_GATEWAY)) == RTF_HOST &&              (rt->rt_flags & (RTF_HOST|RTF_GATEWAY)) == RTF_HOST &&
             !(rt->rt_flags & RTF_CLONED) &&  
 #if 0  #if 0
             /*              /*
              * The check below is redundant since the comparison of               * The check below is redundant since the comparison of
Line 512  ip6_input(struct mbuf *m)
Line 507  ip6_input(struct mbuf *m)
              */               */
             IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, &rt6_getkey(rt)->sin6_addr) &&              IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, &rt6_getkey(rt)->sin6_addr) &&
 #endif  #endif
 #ifdef MOBILE_IPV6              rt->rt_ifp->if_type == IFT_LOOP) {
             ((rt->rt_flags & RTF_ANNOUNCE) ||  
             rt->rt_ifp->if_type == IFT_LOOP)  
 #else  
             rt->rt_ifp->if_type == IFT_LOOP  
 #endif /* MOBILE_IPV6 */  
             ) {  
                 struct in6_ifaddr *ia6 = (struct in6_ifaddr *)rt->rt_ifa;                  struct in6_ifaddr *ia6 = (struct in6_ifaddr *)rt->rt_ifa;
                 if (ia6->ia6_flags & IN6_IFF_ANYCAST)                  if (ia6->ia6_flags & IN6_IFF_ANYCAST)
                         m->m_flags |= M_ANYCAST6;                          m->m_flags |= M_ANYCAST6;
 #ifdef MOBILE_IPV6  
                 /* check unicast NS */  
                 if ((rtcache_validate(&ip6_forward_rt)->rt_flags & RTF_ANNOUNCE) != 0) {  
                         /* This route shows proxy nd. thus the packet was  
                          *  captured. this packet should be tunneled to  
                          * actual coa with tunneling unless this is NS.  
                          */  
                         int nh, loff;  
                         struct icmp6_hdr *icp;  
                         loff = ip6_lasthdr(m, 0, IPPROTO_IPV6, &nh);  
                         if (loff <  0 || nh != IPPROTO_ICMPV6)  
                                 goto mip6_forwarding;  
                         IP6_EXTHDR_GET(icp, struct icmp6_hdr *, m, loff,  
                             sizeof(*icp));  
                         if (icp == NULL) {  
                                 icmp6stat.icp6s_tooshort++;  
                                 return;  
                         }  
                         if (icp->icmp6_type != ND_NEIGHBOR_SOLICIT)  
                                 goto mip6_forwarding;  
                 }  
 #endif /* MOBILE_IPV6 */  
                 /*                  /*
                  * packets to a tentative, duplicated, or somehow invalid                   * packets to a tentative, duplicated, or somehow invalid
                  * address must not be accepted.                   * address must not be accepted.
Line 555  ip6_input(struct mbuf *m)
Line 522  ip6_input(struct mbuf *m)
                         goto hbhcheck;                          goto hbhcheck;
                 } else {                  } else {
                         /* address is not ready, so discard the packet. */                          /* address is not ready, so discard the packet. */
                         nd6log((LOG_INFO,                          nd6log(LOG_INFO, "packet to an unready address %s->%s\n",
                             "ip6_input: packet to an unready address %s->%s\n",  
                             ip6_sprintf(&ip6->ip6_src),                              ip6_sprintf(&ip6->ip6_src),
                             ip6_sprintf(&ip6->ip6_dst)));                              ip6_sprintf(&ip6->ip6_dst));
   
                         goto bad;                          goto bad_unref;
                 }                  }
         }          }
   
 #ifdef MOBILE_IPV6  
  mip6_forwarding:  
 #endif /* MOBILE_IPV6 */  
   
         /*          /*
          * FAITH (Firewall Aided Internet Translator)           * FAITH (Firewall Aided Internet Translator)
          */           */
Line 591  ip6_input(struct mbuf *m)
Line 553  ip6_input(struct mbuf *m)
          * working right.           * working right.
          */           */
         struct ifaddr *ifa;          struct ifaddr *ifa;
         IFADDR_FOREACH(ifa, m->m_pkthdr.rcvif) {          IFADDR_READER_FOREACH(ifa, rcvif) {
                 if (ifa->ifa_addr == NULL)  
                         continue;       /* just for safety */  
                 if (ifa->ifa_addr->sa_family != AF_INET6)                  if (ifa->ifa_addr->sa_family != AF_INET6)
                         continue;                          continue;
                 if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa), &ip6->ip6_dst)) {                  if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa), &ip6->ip6_dst)) {
Line 610  ip6_input(struct mbuf *m)
Line 570  ip6_input(struct mbuf *m)
          * and we're not a router.           * and we're not a router.
          */           */
         if (!ip6_forwarding) {          if (!ip6_forwarding) {
                 ip6stat.ip6s_cantforward++;                  IP6_STATINC(IP6_STAT_CANTFORWARD);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);                  in6_ifstat_inc(rcvif, ifs6_in_discard);
                 goto bad;                  goto bad_unref;
         }          }
   
   hbhcheck:    hbhcheck:
Line 624  ip6_input(struct mbuf *m)
Line 584  ip6_input(struct mbuf *m)
          */           */
         if (deliverifp && ip6_getdstifaddr(m) == NULL) {          if (deliverifp && ip6_getdstifaddr(m) == NULL) {
                 struct in6_ifaddr *ia6;                  struct in6_ifaddr *ia6;
                   int s = pserialize_read_enter();
   
                 ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst);                  ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst);
                   /* Depends on ip6_setdstifaddr never sleep */
                 if (ia6 != NULL && ip6_setdstifaddr(m, ia6) == NULL) {                  if (ia6 != NULL && ip6_setdstifaddr(m, ia6) == NULL) {
                         /*                          /*
                          * XXX maybe we should drop the packet here,                           * XXX maybe we should drop the packet here,
Line 633  ip6_input(struct mbuf *m)
Line 595  ip6_input(struct mbuf *m)
                          * to the upper layers.                           * to the upper layers.
                          */                           */
                 }                  }
                   pserialize_read_exit(s);
         }          }
   
         /*          /*
Line 646  ip6_input(struct mbuf *m)
Line 609  ip6_input(struct mbuf *m)
   
                 if (ip6_hopopts_input(&plen, &rtalert, &m, &off)) {                  if (ip6_hopopts_input(&plen, &rtalert, &m, &off)) {
 #if 0   /*touches NULL pointer*/  #if 0   /*touches NULL pointer*/
                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);                          in6_ifstat_inc(rcvif, ifs6_in_discard);
 #endif  #endif
                           rtcache_unref(rt, ro);
                           percpu_putref(ip6_forward_rt_percpu);
                         return; /* m have already been freed */                          return; /* m have already been freed */
                 }                  }
   
Line 665  ip6_input(struct mbuf *m)
Line 630  ip6_input(struct mbuf *m)
                          * contained, ip6_hopopts_input() must set a valid                           * contained, ip6_hopopts_input() must set a valid
                          * (non-zero) payload length to the variable plen.                           * (non-zero) payload length to the variable plen.
                          */                           */
                         ip6stat.ip6s_badoptions++;                          IP6_STATINC(IP6_STAT_BADOPTIONS);
                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);                          in6_ifstat_inc(rcvif, ifs6_in_discard);
                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);                          in6_ifstat_inc(rcvif, ifs6_in_hdrerr);
                         icmp6_error(m, ICMP6_PARAM_PROB,                          icmp6_error(m, ICMP6_PARAM_PROB,
                                     ICMP6_PARAMPROB_HEADER,                                      ICMP6_PARAMPROB_HEADER,
                                     (char *)&ip6->ip6_plen - (char *)ip6);                                      (char *)&ip6->ip6_plen - (char *)ip6);
                           rtcache_unref(rt, ro);
                           percpu_putref(ip6_forward_rt_percpu);
                         return;                          return;
                 }                  }
                 IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),                  IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),
                         sizeof(struct ip6_hbh));                          sizeof(struct ip6_hbh));
                 if (hbh == NULL) {                  if (hbh == NULL) {
                         ip6stat.ip6s_tooshort++;                          IP6_STATINC(IP6_STAT_TOOSHORT);
                           rtcache_unref(rt, ro);
                           percpu_putref(ip6_forward_rt_percpu);
                         return;                          return;
                 }                  }
                 KASSERT(IP6_HDR_ALIGNED_P(hbh));                  KASSERT(IP6_HDR_ALIGNED_P(hbh));
Line 698  ip6_input(struct mbuf *m)
Line 667  ip6_input(struct mbuf *m)
          * Drop packet if shorter than we expect.           * Drop packet if shorter than we expect.
          */           */
         if (m->m_pkthdr.len - sizeof(struct ip6_hdr) < plen) {          if (m->m_pkthdr.len - sizeof(struct ip6_hdr) < plen) {
                 ip6stat.ip6s_tooshort++;                  IP6_STATINC(IP6_STAT_TOOSHORT);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_truncated);                  in6_ifstat_inc(rcvif, ifs6_in_truncated);
                 goto bad;                  goto bad_unref;
         }          }
         if (m->m_pkthdr.len > sizeof(struct ip6_hdr) + plen) {          if (m->m_pkthdr.len > sizeof(struct ip6_hdr) + plen) {
                 if (m->m_len == m->m_pkthdr.len) {                  if (m->m_len == m->m_pkthdr.len) {
Line 722  ip6_input(struct mbuf *m)
Line 691  ip6_input(struct mbuf *m)
                  * ip6_mforward() returns a non-zero value, the packet                   * ip6_mforward() returns a non-zero value, the packet
                  * must be discarded, else it may be accepted below.                   * must be discarded, else it may be accepted below.
                  */                   */
                 if (ip6_mrouter && ip6_mforward(ip6, m->m_pkthdr.rcvif, m)) {                  if (ip6_mrouter != NULL) {
                         ip6stat.ip6s_cantforward++;                          int error;
                         m_freem(m);  
                         return;                          SOFTNET_LOCK();
                 }                          error = ip6_mforward(ip6, rcvif, m);
                 if (!ours) {                          SOFTNET_UNLOCK();
                         m_freem(m);  
                         return;                          if (error != 0) {
                                   rtcache_unref(rt, ro);
                                   percpu_putref(ip6_forward_rt_percpu);
                                   IP6_STATINC(IP6_STAT_CANTFORWARD);
                                   goto bad;
                           }
                 }                  }
                   if (!ours)
                           goto bad_unref;
         } else if (!ours) {          } else if (!ours) {
                   rtcache_unref(rt, ro);
                   percpu_putref(ip6_forward_rt_percpu);
                 ip6_forward(m, srcrt);                  ip6_forward(m, srcrt);
                 return;                  return;
         }          }
Line 749  ip6_input(struct mbuf *m)
Line 727  ip6_input(struct mbuf *m)
          */           */
         if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||          if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
             IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {              IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
                 ip6stat.ip6s_badscope++;                  IP6_STATINC(IP6_STAT_BADSCOPE);
                 in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);                  in6_ifstat_inc(rcvif, ifs6_in_addrerr);
                 goto bad;                  goto bad_unref;
         }          }
   
         /*          /*
Line 760  ip6_input(struct mbuf *m)
Line 738  ip6_input(struct mbuf *m)
 #ifdef IFA_STATS  #ifdef IFA_STATS
         if (deliverifp != NULL) {          if (deliverifp != NULL) {
                 struct in6_ifaddr *ia6;                  struct in6_ifaddr *ia6;
                   int s = pserialize_read_enter();
                 ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst);                  ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst);
                 if (ia6)                  if (ia6)
                         ia6->ia_ifa.ifa_data.ifad_inbytes += m->m_pkthdr.len;                          ia6->ia_ifa.ifa_data.ifad_inbytes += m->m_pkthdr.len;
                   pserialize_read_exit(s);
         }          }
 #endif  #endif
         ip6stat.ip6s_delivered++;          IP6_STATINC(IP6_STAT_DELIVERED);
         in6_ifstat_inc(deliverifp, ifs6_in_deliver);          in6_ifstat_inc(deliverifp, ifs6_in_deliver);
         nest = 0;          nest = 0;
   
           if (rt != NULL) {
                   rtcache_unref(rt, ro);
                   rt = NULL;
           }
           percpu_putref(ip6_forward_rt_percpu);
   
         rh_present = 0;          rh_present = 0;
         while (nxt != IPPROTO_DONE) {          while (nxt != IPPROTO_DONE) {
                 if (ip6_hdrnestlimit && (++nest > ip6_hdrnestlimit)) {                  if (ip6_hdrnestlimit && (++nest > ip6_hdrnestlimit)) {
                         ip6stat.ip6s_toomanyhdr++;                          IP6_STATINC(IP6_STAT_TOOMANYHDR);
                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);                          in6_ifstat_inc(rcvif, ifs6_in_hdrerr);
                         goto bad;                          goto bad;
                 }                  }
   
Line 782  ip6_input(struct mbuf *m)
Line 768  ip6_input(struct mbuf *m)
                  * more sanity checks in header chain processing.                   * more sanity checks in header chain processing.
                  */                   */
                 if (m->m_pkthdr.len < off) {                  if (m->m_pkthdr.len < off) {
                         ip6stat.ip6s_tooshort++;                          IP6_STATINC(IP6_STAT_TOOSHORT);
                         in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_truncated);                          in6_ifstat_inc(rcvif, ifs6_in_truncated);
                         goto bad;                          goto bad;
                 }                  }
   
                 if (nxt == IPPROTO_ROUTING) {                  if (nxt == IPPROTO_ROUTING) {
                         if (rh_present++) {                          if (rh_present++) {
                                 in6_ifstat_inc(m->m_pkthdr.rcvif,                                  in6_ifstat_inc(rcvif, ifs6_in_hdrerr);
                                     ifs6_in_hdrerr);                                  IP6_STATINC(IP6_STAT_BADOPTIONS);
                                 ip6stat.ip6s_badoptions++;  
                                 goto bad;                                  goto bad;
                         }                          }
                 }                  }
   
 #ifdef IPSEC  #ifdef IPSEC
                 /*                  if (ipsec_used) {
                  * enforce IPsec policy checking if we are seeing last header.  
                  * note that we do not visit this with protocols with pcb layer  
                  * code - like udp/tcp/raw ip.  
                  */  
                 if ((inet6sw[ip6_protox[nxt]].pr_flags & PR_LASTHDR) != 0 &&  
                     ipsec6_in_reject(m, NULL)) {  
                         ipsec6stat.in_polvio++;  
                         goto bad;  
                 }  
 #endif  
 #ifdef FAST_IPSEC  
         /*  
          * enforce IPsec policy checking if we are seeing last header.  
          * note that we do not visit this with protocols with pcb layer  
          * code - like udp/tcp/raw ip.  
          */  
         if ((inet6sw[ip_protox[nxt]].pr_flags & PR_LASTHDR) != 0) {  
                 /*  
                  * Check if the packet has already had IPsec processing  
                  * done.  If so, then just pass it along.  This tag gets  
                  * set during AH, ESP, etc. input handling, before the  
                  * packet is returned to the ip input queue for delivery.  
                  */  
                 mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL);  
                 s = splsoftnet();  
                 if (mtag != NULL) {  
                         tdbi = (struct tdb_ident *)(mtag + 1);  
                         sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND);  
                 } else {  
                         sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND,  
                                                                         IP_FORWARDING, &error);  
                 }  
                 if (sp != NULL) {  
                         /*                          /*
                          * Check security policy against packet attributes.                           * enforce IPsec policy checking if we are seeing last
                            * header. note that we do not visit this with
                            * protocols with pcb layer code - like udp/tcp/raw ip.
                          */                           */
                         error = ipsec_in_reject(sp, m);                          if ((inet6sw[ip_protox[nxt]].pr_flags
                         KEY_FREESP(&sp);                              & PR_LASTHDR) != 0) {
                 } else {                                  int error;
                         /* XXX error stat??? */  
                         error = EINVAL;                                  SOFTNET_LOCK();
                         DPRINTF(("ip6_input: no SP, packet discarded\n"));/*XXX*/                                  error = ipsec6_input(m);
                                   SOFTNET_UNLOCK();
                                   if (error)
                                           goto bad;
                           }
                 }                  }
                 splx(s);  #endif /* IPSEC */
                 if (error)  
                         goto bad;  
         }  
 #endif /* FAST_IPSEC */  
   
                 if (dest6_mip6_hao(m, off, nxt) < 0)  
                         goto bad;  
   
                   SOFTNET_LOCK();
                 nxt = (*inet6sw[ip6_protox[nxt]].pr_input)(&m, &off, nxt);                  nxt = (*inet6sw[ip6_protox[nxt]].pr_input)(&m, &off, nxt);
                   SOFTNET_UNLOCK();
         }          }
         return;          return;
   
    bad_unref:
           rtcache_unref(rt, ro);
           percpu_putref(ip6_forward_rt_percpu);
  bad:   bad:
         m_freem(m);          m_freem(m);
           return;
 }  }
   
 /*  /*
Line 864  static struct m_tag *
Line 822  static struct m_tag *
 ip6_setdstifaddr(struct mbuf *m, const struct in6_ifaddr *ia)  ip6_setdstifaddr(struct mbuf *m, const struct in6_ifaddr *ia)
 {  {
         struct m_tag *mtag;          struct m_tag *mtag;
           struct ip6aux *ip6a;
   
         mtag = ip6_addaux(m);          mtag = ip6_addaux(m);
         if (mtag != NULL) {          if (mtag == NULL)
                 struct ip6aux *ip6a;                  return NULL;
   
                 ip6a = (struct ip6aux *)(mtag + 1);          ip6a = (struct ip6aux *)(mtag + 1);
                 in6_setscope(&ip6a->ip6a_src, ia->ia_ifp, &ip6a->ip6a_src_scope_id);          if (in6_setscope(&ip6a->ip6a_src, ia->ia_ifp, &ip6a->ip6a_scope_id)) {
                 ip6a->ip6a_src = ia->ia_addr.sin6_addr;                  IP6_STATINC(IP6_STAT_BADSCOPE);
                 ip6a->ip6a_src_flags = ia->ia6_flags;                  return NULL;
         }          }
         return mtag;    /* NULL if failed to set */  
           ip6a->ip6a_src = ia->ia_addr.sin6_addr;
           ip6a->ip6a_flags = ia->ia6_flags;
           return mtag;
 }  }
   
 const struct ip6aux *  const struct ip6aux *
Line 895  ip6_getdstifaddr(struct mbuf *m)
Line 857  ip6_getdstifaddr(struct mbuf *m)
  *   *
  * rtalertp - XXX: should be stored more smart way   * rtalertp - XXX: should be stored more smart way
  */   */
 static int  int
 ip6_hopopts_input(u_int32_t *plenp, u_int32_t *rtalertp,  ip6_hopopts_input(u_int32_t *plenp, u_int32_t *rtalertp,
         struct mbuf **mp, int *offp)          struct mbuf **mp, int *offp)
 {  {
Line 907  ip6_hopopts_input(u_int32_t *plenp, u_in
Line 869  ip6_hopopts_input(u_int32_t *plenp, u_in
         IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,          IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,
                 sizeof(struct ip6_hdr), sizeof(struct ip6_hbh));                  sizeof(struct ip6_hdr), sizeof(struct ip6_hbh));
         if (hbh == NULL) {          if (hbh == NULL) {
                 ip6stat.ip6s_tooshort++;                  IP6_STATINC(IP6_STAT_TOOSHORT);
                 return -1;                  return -1;
         }          }
         hbhlen = (hbh->ip6h_len + 1) << 3;          hbhlen = (hbh->ip6h_len + 1) << 3;
         IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),          IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),
                 hbhlen);                  hbhlen);
         if (hbh == NULL) {          if (hbh == NULL) {
                 ip6stat.ip6s_tooshort++;                  IP6_STATINC(IP6_STAT_TOOSHORT);
                 return -1;                  return -1;
         }          }
         KASSERT(IP6_HDR_ALIGNED_P(hbh));          KASSERT(IP6_HDR_ALIGNED_P(hbh));
Line 940  ip6_hopopts_input(u_int32_t *plenp, u_in
Line 902  ip6_hopopts_input(u_int32_t *plenp, u_in
  * (RFC2460 p7), opthead is pointer into data content in m, and opthead to   * (RFC2460 p7), opthead is pointer into data content in m, and opthead to
  * opthead + hbhlen is located in continuous memory region.   * opthead + hbhlen is located in continuous memory region.
  */   */
 int  static int
 ip6_process_hopopts(struct mbuf *m, u_int8_t *opthead, int hbhlen,  ip6_process_hopopts(struct mbuf *m, u_int8_t *opthead, int hbhlen,
         u_int32_t *rtalertp, u_int32_t *plenp)          u_int32_t *rtalertp, u_int32_t *plenp)
 {  {
Line 958  ip6_process_hopopts(struct mbuf *m, u_in
Line 920  ip6_process_hopopts(struct mbuf *m, u_in
                         break;                          break;
                 case IP6OPT_PADN:                  case IP6OPT_PADN:
                         if (hbhlen < IP6OPT_MINLEN) {                          if (hbhlen < IP6OPT_MINLEN) {
                                 ip6stat.ip6s_toosmall++;                                  IP6_STATINC(IP6_STAT_TOOSMALL);
                                 goto bad;                                  goto bad;
                         }                          }
                         optlen = *(opt + 1) + 2;                          optlen = *(opt + 1) + 2;
Line 966  ip6_process_hopopts(struct mbuf *m, u_in
Line 928  ip6_process_hopopts(struct mbuf *m, u_in
                 case IP6OPT_RTALERT:                  case IP6OPT_RTALERT:
                         /* XXX may need check for alignment */                          /* XXX may need check for alignment */
                         if (hbhlen < IP6OPT_RTALERT_LEN) {                          if (hbhlen < IP6OPT_RTALERT_LEN) {
                                 ip6stat.ip6s_toosmall++;                                  IP6_STATINC(IP6_STAT_TOOSMALL);
                                 goto bad;                                  goto bad;
                         }                          }
                         if (*(opt + 1) != IP6OPT_RTALERT_LEN - 2) {                          if (*(opt + 1) != IP6OPT_RTALERT_LEN - 2) {
Line 977  ip6_process_hopopts(struct mbuf *m, u_in
Line 939  ip6_process_hopopts(struct mbuf *m, u_in
                                 return (-1);                                  return (-1);
                         }                          }
                         optlen = IP6OPT_RTALERT_LEN;                          optlen = IP6OPT_RTALERT_LEN;
                         bcopy((void *)(opt + 2), (void *)&rtalert_val, 2);                          memcpy((void *)&rtalert_val, (void *)(opt + 2), 2);
                         *rtalertp = ntohs(rtalert_val);                          *rtalertp = ntohs(rtalert_val);
                         break;                          break;
                 case IP6OPT_JUMBO:                  case IP6OPT_JUMBO:
                         /* XXX may need check for alignment */                          /* XXX may need check for alignment */
                         if (hbhlen < IP6OPT_JUMBO_LEN) {                          if (hbhlen < IP6OPT_JUMBO_LEN) {
                                 ip6stat.ip6s_toosmall++;                                  IP6_STATINC(IP6_STAT_TOOSMALL);
                                 goto bad;                                  goto bad;
                         }                          }
                         if (*(opt + 1) != IP6OPT_JUMBO_LEN - 2) {                          if (*(opt + 1) != IP6OPT_JUMBO_LEN - 2) {
Line 1001  ip6_process_hopopts(struct mbuf *m, u_in
Line 963  ip6_process_hopopts(struct mbuf *m, u_in
                          */                           */
                         ip6 = mtod(m, struct ip6_hdr *);                          ip6 = mtod(m, struct ip6_hdr *);
                         if (ip6->ip6_plen) {                          if (ip6->ip6_plen) {
                                 ip6stat.ip6s_badoptions++;                                  IP6_STATINC(IP6_STAT_BADOPTIONS);
                                 icmp6_error(m, ICMP6_PARAM_PROB,                                  icmp6_error(m, ICMP6_PARAM_PROB,
                                     ICMP6_PARAMPROB_HEADER,                                      ICMP6_PARAMPROB_HEADER,
                                     erroff + opt - opthead);                                      erroff + opt - opthead);
Line 1012  ip6_process_hopopts(struct mbuf *m, u_in
Line 974  ip6_process_hopopts(struct mbuf *m, u_in
                          * We may see jumbolen in unaligned location, so                           * We may see jumbolen in unaligned location, so
                          * we'd need to perform bcopy().                           * we'd need to perform bcopy().
                          */                           */
                         bcopy(opt + 2, &jumboplen, sizeof(jumboplen));                          memcpy(&jumboplen, opt + 2, sizeof(jumboplen));
                         jumboplen = (u_int32_t)htonl(jumboplen);                          jumboplen = (u_int32_t)htonl(jumboplen);
   
 #if 1  #if 1
Line 1025  ip6_process_hopopts(struct mbuf *m, u_in
Line 987  ip6_process_hopopts(struct mbuf *m, u_in
                          * there's no explicit mention in specification.                           * there's no explicit mention in specification.
                          */                           */
                         if (*plenp != 0) {                          if (*plenp != 0) {
                                 ip6stat.ip6s_badoptions++;                                  IP6_STATINC(IP6_STAT_BADOPTIONS);
                                 icmp6_error(m, ICMP6_PARAM_PROB,                                  icmp6_error(m, ICMP6_PARAM_PROB,
                                     ICMP6_PARAMPROB_HEADER,                                      ICMP6_PARAMPROB_HEADER,
                                     erroff + opt + 2 - opthead);                                      erroff + opt + 2 - opthead);
Line 1037  ip6_process_hopopts(struct mbuf *m, u_in
Line 999  ip6_process_hopopts(struct mbuf *m, u_in
                          * jumbo payload length must be larger than 65535.                           * jumbo payload length must be larger than 65535.
                          */                           */
                         if (jumboplen <= IPV6_MAXPACKET) {                          if (jumboplen <= IPV6_MAXPACKET) {
                                 ip6stat.ip6s_badoptions++;                                  IP6_STATINC(IP6_STAT_BADOPTIONS);
                                 icmp6_error(m, ICMP6_PARAM_PROB,                                  icmp6_error(m, ICMP6_PARAM_PROB,
                                     ICMP6_PARAMPROB_HEADER,                                      ICMP6_PARAMPROB_HEADER,
                                     erroff + opt + 2 - opthead);                                      erroff + opt + 2 - opthead);
Line 1048  ip6_process_hopopts(struct mbuf *m, u_in
Line 1010  ip6_process_hopopts(struct mbuf *m, u_in
                         break;                          break;
                 default:                /* unknown option */                  default:                /* unknown option */
                         if (hbhlen < IP6OPT_MINLEN) {                          if (hbhlen < IP6OPT_MINLEN) {
                                 ip6stat.ip6s_toosmall++;                                  IP6_STATINC(IP6_STAT_TOOSMALL);
                                 goto bad;                                  goto bad;
                         }                          }
                         optlen = ip6_unknown_opt(opt, m,                          optlen = ip6_unknown_opt(opt, m,
Line 1085  ip6_unknown_opt(u_int8_t *optp, struct m
Line 1047  ip6_unknown_opt(u_int8_t *optp, struct m
                 m_freem(m);                  m_freem(m);
                 return (-1);                  return (-1);
         case IP6OPT_TYPE_FORCEICMP: /* send ICMP even if multicasted */          case IP6OPT_TYPE_FORCEICMP: /* send ICMP even if multicasted */
                 ip6stat.ip6s_badoptions++;                  IP6_STATINC(IP6_STAT_BADOPTIONS);
                 icmp6_error(m, ICMP6_PARAM_PROB, ICMP6_PARAMPROB_OPTION, off);                  icmp6_error(m, ICMP6_PARAM_PROB, ICMP6_PARAMPROB_OPTION, off);
                 return (-1);                  return (-1);
         case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */          case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */
                 ip6stat.ip6s_badoptions++;                  IP6_STATINC(IP6_STAT_BADOPTIONS);
                 ip6 = mtod(m, struct ip6_hdr *);                  ip6 = mtod(m, struct ip6_hdr *);
                 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) ||                  if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) ||
                     (m->m_flags & (M_BCAST|M_MCAST)))                      (m->m_flags & (M_BCAST|M_MCAST)))
Line 1125  ip6_savecontrol(struct in6pcb *in6p, str
Line 1087  ip6_savecontrol(struct in6pcb *in6p, str
 #define IS2292(x, y)    (y)  #define IS2292(x, y)    (y)
 #endif  #endif
   
 #ifdef SO_TIMESTAMP          if (in6p->in6p_socket->so_options & SO_TIMESTAMP
         if (in6p->in6p_socket->so_options & SO_TIMESTAMP) {  #ifdef SO_OTIMESTAMP
               || in6p->in6p_socket->so_options & SO_OTIMESTAMP
   #endif
           ) {
                 struct timeval tv;                  struct timeval tv;
   
                 microtime(&tv);                  microtime(&tv);
   #ifdef SO_OTIMESTAMP
                   if (in6p->in6p_socket->so_options & SO_OTIMESTAMP) {
                           struct timeval50 tv50;
                           timeval_to_timeval50(&tv, &tv50);
                           *mp = sbcreatecontrol((void *) &tv50, sizeof(tv50),
                               SCM_OTIMESTAMP, SOL_SOCKET);
                   } else
   #endif
                 *mp = sbcreatecontrol((void *) &tv, sizeof(tv),                  *mp = sbcreatecontrol((void *) &tv, sizeof(tv),
                     SCM_TIMESTAMP, SOL_SOCKET);                      SCM_TIMESTAMP, SOL_SOCKET);
                 if (*mp)                  if (*mp)
                         mp = &(*mp)->m_next;                          mp = &(*mp)->m_next;
         }          }
 #endif  
   
         /* some OSes call this logic with IPv4 packet, for SO_TIMESTAMP */          /* some OSes call this logic with IPv4 packet, for SO_TIMESTAMP */
         if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION)          if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION)
Line 1145  ip6_savecontrol(struct in6pcb *in6p, str
Line 1117  ip6_savecontrol(struct in6pcb *in6p, str
         if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) {          if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) {
                 struct in6_pktinfo pi6;                  struct in6_pktinfo pi6;
   
                 bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr));                  memcpy(&pi6.ipi6_addr, &ip6->ip6_dst, sizeof(struct in6_addr));
                 in6_clearscope(&pi6.ipi6_addr); /* XXX */                  in6_clearscope(&pi6.ipi6_addr); /* XXX */
                 pi6.ipi6_ifindex = m->m_pkthdr.rcvif ?                  pi6.ipi6_ifindex = m->m_pkthdr.rcvif_index;
                     m->m_pkthdr.rcvif->if_index : 0;  
                 *mp = sbcreatecontrol((void *) &pi6,                  *mp = sbcreatecontrol((void *) &pi6,
                     sizeof(struct in6_pktinfo),                      sizeof(struct in6_pktinfo),
                     IS2292(IPV6_2292PKTINFO, IPV6_PKTINFO), IPPROTO_IPV6);                      IS2292(IPV6_2292PKTINFO, IPV6_PKTINFO), IPPROTO_IPV6);
Line 1204  ip6_savecontrol(struct in6pcb *in6p, str
Line 1175  ip6_savecontrol(struct in6pcb *in6p, str
                         ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr),                          ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr),
                             xip6->ip6_nxt);                              xip6->ip6_nxt);
                         if (ext == NULL) {                          if (ext == NULL) {
                                 ip6stat.ip6s_tooshort++;                                  IP6_STATINC(IP6_STAT_TOOSHORT);
                                 return;                                  return;
                         }                          }
                         hbh = mtod(ext, struct ip6_hbh *);                          hbh = mtod(ext, struct ip6_hbh *);
                         hbhlen = (hbh->ip6h_len + 1) << 3;                          hbhlen = (hbh->ip6h_len + 1) << 3;
                         if (hbhlen != ext->m_len) {                          if (hbhlen != ext->m_len) {
                                 m_freem(ext);                                  m_freem(ext);
                                 ip6stat.ip6s_tooshort++;                                  IP6_STATINC(IP6_STAT_TOOSHORT);
                                 return;                                  return;
                         }                          }
   
Line 1263  ip6_savecontrol(struct in6pcb *in6p, str
Line 1234  ip6_savecontrol(struct in6pcb *in6p, str
   
                         ext = ip6_pullexthdr(m, off, nxt);                          ext = ip6_pullexthdr(m, off, nxt);
                         if (ext == NULL) {                          if (ext == NULL) {
                                 ip6stat.ip6s_tooshort++;                                  IP6_STATINC(IP6_STAT_TOOSHORT);
                                 return;                                  return;
                         }                          }
                         ip6e = mtod(ext, struct ip6_ext *);                          ip6e = mtod(ext, struct ip6_ext *);
Line 1273  ip6_savecontrol(struct in6pcb *in6p, str
Line 1244  ip6_savecontrol(struct in6pcb *in6p, str
                                 elen = (ip6e->ip6e_len + 1) << 3;                                  elen = (ip6e->ip6e_len + 1) << 3;
                         if (elen != ext->m_len) {                          if (elen != ext->m_len) {
                                 m_freem(ext);                                  m_freem(ext);
                                 ip6stat.ip6s_tooshort++;                                  IP6_STATINC(IP6_STAT_TOOSHORT);
                                 return;                                  return;
                         }                          }
                         KASSERT(IP6_HDR_ALIGNED_P(ip6e));                          KASSERT(IP6_HDR_ALIGNED_P(ip6e));
   
                         switch (nxt) {                          switch (nxt) {
                         case IPPROTO_DSTOPTS:                          case IPPROTO_DSTOPTS:
                                 if (!in6p->in6p_flags & IN6P_DSTOPTS)                                  if (!(in6p->in6p_flags & IN6P_DSTOPTS))
                                         break;                                          break;
   
                                 *mp = sbcreatecontrol((void *)ip6e, elen,                                  *mp = sbcreatecontrol((void *)ip6e, elen,
Line 1291  ip6_savecontrol(struct in6pcb *in6p, str
Line 1262  ip6_savecontrol(struct in6pcb *in6p, str
                                 break;                                  break;
   
                         case IPPROTO_ROUTING:                          case IPPROTO_ROUTING:
                                 if (!in6p->in6p_flags & IN6P_RTHDR)                                  if (!(in6p->in6p_flags & IN6P_RTHDR))
                                         break;                                          break;
   
                                 *mp = sbcreatecontrol((void *)ip6e, elen,                                  *mp = sbcreatecontrol((void *)ip6e, elen,
Line 1585  ip6_addaux(struct mbuf *m)
Line 1556  ip6_addaux(struct mbuf *m)
                     M_NOWAIT);                      M_NOWAIT);
                 if (mtag) {                  if (mtag) {
                         m_tag_prepend(m, mtag);                          m_tag_prepend(m, mtag);
                         bzero(mtag + 1, sizeof(struct ip6aux));                          memset(mtag + 1, 0, sizeof(struct ip6aux));
                 }                  }
         }          }
         return mtag;          return mtag;
Line 1610  ip6_delaux(struct mbuf *m)
Line 1581  ip6_delaux(struct mbuf *m)
                 m_tag_delete(m, mtag);                  m_tag_delete(m, mtag);
 }  }
   
 #ifdef GATEWAY  
 /*  
  * sysctl helper routine for net.inet.ip6.maxflows. Since  
  * we could reduce this value, call ip6flow_reap();  
  */  
 static int  
 sysctl_net_inet6_ip6_maxflows(SYSCTLFN_ARGS)  
 {  
         int s;  
   
         s = sysctl_lookup(SYSCTLFN_CALL(rnode));  
         if (s || newp == NULL)  
                 return (s);  
   
         s = splsoftnet();  
         ip6flow_reap(0);  
         splx(s);  
   
         return (0);  
 }  
   
 static int  
 sysctl_net_inet6_ip6_hashsize(SYSCTLFN_ARGS)  
 {  
         int error, tmp;  
         struct sysctlnode node;  
   
         node = *rnode;  
         tmp = ip6_hashsize;  
         node.sysctl_data = &tmp;  
         error = sysctl_lookup(SYSCTLFN_CALL(&node));  
         if (error || newp == NULL)  
                 return (error);  
   
         if ((tmp & (tmp - 1)) == 0 && tmp != 0) {  
                 /*  
                  * Can only fail due to malloc()  
                  */  
                 if (ip6flow_invalidate_all(tmp))  
                         return ENOMEM;  
         } else {  
                 /*  
                  * EINVAL if not a power of 2  
                  */  
                 return EINVAL;  
         }  
   
         return (0);  
 }  
 #endif /* GATEWAY */  
   
 /*  /*
  * System control for IP6   * System control for IP6
  */   */
   
 u_char  inet6ctlerrmap[PRC_NCMDS] = {  const u_char inet6ctlerrmap[PRC_NCMDS] = {
         0,              0,              0,              0,          0,              0,              0,              0,
         0,              EMSGSIZE,       EHOSTDOWN,      EHOSTUNREACH,          0,              EMSGSIZE,       EHOSTDOWN,      EHOSTUNREACH,
         EHOSTUNREACH,   EHOSTUNREACH,   ECONNREFUSED,   ECONNREFUSED,          EHOSTUNREACH,   EHOSTUNREACH,   ECONNREFUSED,   ECONNREFUSED,
Line 1674  u_char inet6ctlerrmap[PRC_NCMDS] = {
Line 1594  u_char inet6ctlerrmap[PRC_NCMDS] = {
         ENOPROTOOPT          ENOPROTOOPT
 };  };
   
 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup")  extern int sysctl_net_inet6_addrctlpolicy(SYSCTLFN_ARGS);
   
   static int
   sysctl_net_inet6_ip6_stats(SYSCTLFN_ARGS)
   {
   
           return (NETSTAT_SYSCTL(ip6stat_percpu, IP6_NSTATS));
   }
   
   static void
   sysctl_net_inet6_ip6_setup(struct sysctllog **clog)
 {  {
 #ifdef RFC2292  #ifdef RFC2292
 #define IS2292(x, y)    ((in6p->in6p_flags & IN6P_RFC2292) ? (x) : (y))  #define IS2292(x, y)    ((in6p->in6p_flags & IN6P_RFC2292) ? (x) : (y))
Line 1684  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1614  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
   
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                        CTLFLAG_PERMANENT,                         CTLFLAG_PERMANENT,
                        CTLTYPE_NODE, "net", NULL,  
                        NULL, 0, NULL, 0,  
                        CTL_NET, CTL_EOL);  
         sysctl_createv(clog, 0, NULL, NULL,  
                        CTLFLAG_PERMANENT,  
                        CTLTYPE_NODE, "inet6",                         CTLTYPE_NODE, "inet6",
                        SYSCTL_DESCR("PF_INET6 related settings"),                         SYSCTL_DESCR("PF_INET6 related settings"),
                        NULL, 0, NULL, 0,                         NULL, 0, NULL, 0,
Line 1780  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1705  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
                        IPV6CTL_ACCEPT_RTADV, CTL_EOL);                         IPV6CTL_ACCEPT_RTADV, CTL_EOL);
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "rtadv_maxroutes",
                          SYSCTL_DESCR("Maximum number of routes accepted via router advertisements"),
                          NULL, 0, &ip6_rtadv_maxroutes, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_RTADV_MAXROUTES, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT,
                          CTLTYPE_INT, "rtadv_numroutes",
                          SYSCTL_DESCR("Current number of routes accepted via router advertisements"),
                          NULL, 0, &nd6_numroutes, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_RTADV_NUMROUTES, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                        CTLTYPE_INT, "keepfaith",                         CTLTYPE_INT, "keepfaith",
                        SYSCTL_DESCR("Activate faith interface"),                         SYSCTL_DESCR("Activate faith interface"),
                        NULL, 0, &ip6_keepfaith, 0,                         NULL, 0, &ip6_keepfaith, 0,
Line 1822  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1761  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
                        NULL, 0, &ip6_defmcasthlim, 0,                         NULL, 0, &ip6_defmcasthlim, 0,
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                        IPV6CTL_DEFMCASTHLIM, CTL_EOL);                         IPV6CTL_DEFMCASTHLIM, CTL_EOL);
 #if NGIF > 0  
         sysctl_createv(clog, 0, NULL, NULL,  
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,  
                        CTLTYPE_INT, "gifhlim",  
                        SYSCTL_DESCR("Default hop limit for a gif tunnel datagram"),  
                        NULL, 0, &ip6_gif_hlim, 0,  
                        CTL_NET, PF_INET6, IPPROTO_IPV6,  
                        IPV6CTL_GIF_HLIM, CTL_EOL);  
 #endif /* NGIF */  
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                        CTLFLAG_PERMANENT,                         CTLFLAG_PERMANENT,
                        CTLTYPE_STRING, "kame_version",                         CTLTYPE_STRING, "kame_version",
Line 1897  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1827  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
 #endif /* IPNOPRIVPORTS */  #endif /* IPNOPRIVPORTS */
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "auto_linklocal",
                          SYSCTL_DESCR("Default value of per-interface flag for "
                                       "adding an IPv6 link-local address to "
                                       "interfaces when attached"),
                          NULL, 0, &ip6_auto_linklocal, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_AUTO_LINKLOCAL, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READONLY,
                          CTLTYPE_STRUCT, "addctlpolicy",
                          SYSCTL_DESCR("Return the current address control"
                              " policy"),
                          sysctl_net_inet6_addrctlpolicy, 0, NULL, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_ADDRCTLPOLICY, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                        CTLTYPE_INT, "use_tempaddr",                         CTLTYPE_INT, "use_tempaddr",
                        SYSCTL_DESCR("Use temporary address"),                         SYSCTL_DESCR("Use temporary address"),
                        NULL, 0, &ip6_use_tempaddr, 0,                         NULL, 0, &ip6_use_tempaddr, 0,
Line 1904  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1851  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
                        CTL_CREATE, CTL_EOL);                         CTL_CREATE, CTL_EOL);
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "prefer_tempaddr",
                          SYSCTL_DESCR("Prefer temporary address as source "
                                       "address"),
                          NULL, 0, &ip6_prefer_tempaddr, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          CTL_CREATE, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                        CTLTYPE_INT, "temppltime",                         CTLTYPE_INT, "temppltime",
                        SYSCTL_DESCR("preferred lifetime of a temporary address"),                         SYSCTL_DESCR("preferred lifetime of a temporary address"),
                        NULL, 0, &ip6_temp_preferred_lifetime, 0,                         NULL, 0, &ip6_temp_preferred_lifetime, 0,
Line 1927  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1882  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
                        CTLFLAG_PERMANENT,                         CTLFLAG_PERMANENT,
                        CTLTYPE_STRUCT, "stats",                         CTLTYPE_STRUCT, "stats",
                        SYSCTL_DESCR("IPv6 statistics"),                         SYSCTL_DESCR("IPv6 statistics"),
                        NULL, 0, &ip6stat, sizeof(ip6stat),                         sysctl_net_inet6_ip6_stats, 0, NULL, 0,
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                        IPV6CTL_STATS, CTL_EOL);                         IPV6CTL_STATS, CTL_EOL);
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
Line 1944  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
Line 1899  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,
                        NULL, 0, &ip6_mcast_pmtu, 0,                         NULL, 0, &ip6_mcast_pmtu, 0,
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                        CTL_CREATE, CTL_EOL);                         CTL_CREATE, CTL_EOL);
 #ifdef GATEWAY          /* anonportalgo RFC6056 subtree */
           const struct sysctlnode *portalgo_node;
           sysctl_createv(clog, 0, NULL, &portalgo_node,
                          CTLFLAG_PERMANENT,
                          CTLTYPE_NODE, "anonportalgo",
                          SYSCTL_DESCR("Anonymous port algorithm selection (RFC 6056)"),
                          NULL, 0, NULL, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_CREATE, CTL_EOL);
           sysctl_createv(clog, 0, &portalgo_node, NULL,
                          CTLFLAG_PERMANENT,
                          CTLTYPE_STRING, "available",
                          SYSCTL_DESCR("available algorithms"),
                          sysctl_portalgo_available, 0, NULL, PORTALGO_MAXLEN,
                          CTL_CREATE, CTL_EOL);
           sysctl_createv(clog, 0, &portalgo_node, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_STRING, "selected",
                          SYSCTL_DESCR("selected algorithm"),
                          sysctl_portalgo_selected6, 0, NULL, PORTALGO_MAXLEN,
                          CTL_CREATE, CTL_EOL);
           sysctl_createv(clog, 0, &portalgo_node, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_STRUCT, "reserve",
                          SYSCTL_DESCR("bitmap of reserved ports"),
                          sysctl_portalgo_reserve6, 0, NULL, 0,
                          CTL_CREATE, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "neighborgcthresh",
                          SYSCTL_DESCR("Maximum number of entries in neighbor"
                           " cache"),
                          NULL, 1, &ip6_neighborgcthresh, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          CTL_CREATE, CTL_EOL);
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                         CTLTYPE_INT, "maxflows",                         CTLTYPE_INT, "maxifprefixes",
                         SYSCTL_DESCR("Number of flows for fast forwarding (IPv6)"),                         SYSCTL_DESCR("Maximum number of prefixes created by"
                         sysctl_net_inet6_ip6_maxflows, 0, &ip6_maxflows, 0,                             " route advertisement per interface"),
                         CTL_NET, PF_INET6, IPPROTO_IPV6,                         NULL, 1, &ip6_maxifprefixes, 0,
                         CTL_CREATE, CTL_EOL);                         CTL_NET, PF_INET6, IPPROTO_IPV6,
         sysctl_createv(clog, 0, NULL, NULL,                         CTL_CREATE, CTL_EOL);
                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,          sysctl_createv(clog, 0, NULL, NULL,
                         CTLTYPE_INT, "hashsize",                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                         SYSCTL_DESCR("Size of hash table for fast forwarding (IPv6)"),                         CTLTYPE_INT, "maxifdefrouters",
                         sysctl_net_inet6_ip6_hashsize, 0, &ip6_hashsize, 0,                         SYSCTL_DESCR("Maximum number of default routers created"
                         CTL_NET, PF_INET6, IPPROTO_IPV6,                             " by route advertisement per interface"),
                         CTL_CREATE, CTL_EOL);                         NULL, 1, &ip6_maxifdefrouters, 0,
 #endif                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                          CTL_CREATE, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "maxdynroutes",
                          SYSCTL_DESCR("Maximum number of routes created via"
                              " redirect"),
                          NULL, 1, &ip6_maxdynroutes, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          CTL_CREATE, CTL_EOL);
   }
   
   void
   ip6_statinc(u_int stat)
   {
   
           KASSERT(stat < IP6_NSTATS);
           IP6_STATINC(stat);
 }  }

Legend:
Removed from v.1.113.8.2  
changed lines
  Added in v.1.164.2.3

CVSweb <webmaster@jp.NetBSD.org>