[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.62 and 1.64.2.1

version 1.62, 2003/05/14 14:34:14 version 1.64.2.1, 2004/08/03 10:55:13
Line 42 
Line 42 
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software   * 3. Neither the name of the University nor the names of its contributors
  *    must display the following acknowledgement:  
  *      This product includes software developed by the University of  
  *      California, Berkeley and its contributors.  
  * 4. Neither the name of the University nor the names of its contributors  
  *    may be used to endorse or promote products derived from this software   *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.   *    without specific prior written permission.
  *   *
Line 174  ip6_init()
Line 170  ip6_init()
         ip6intrq.ifq_maxlen = ip6qmaxlen;          ip6intrq.ifq_maxlen = ip6qmaxlen;
         nd6_init();          nd6_init();
         frag6_init();          frag6_init();
         ip6_flow_seq = arc4random();  
   
         ip6_init2((void *)0);          ip6_init2((void *)0);
   
Line 230  ip6_input(m)
Line 225  ip6_input(m)
         u_int32_t rtalert = ~0;          u_int32_t rtalert = ~0;
         int nxt, ours = 0;          int nxt, ours = 0;
         struct ifnet *deliverifp = NULL;          struct ifnet *deliverifp = NULL;
           int srcrt = 0;
   
 #ifdef IPSEC  #ifdef IPSEC
         /*          /*
Line 315  ip6_input(m)
Line 311  ip6_input(m)
         if (1)          if (1)
 #endif  #endif
         {          {
                   struct in6_addr odst;
   
                   odst = ip6->ip6_dst;
                 if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.rcvif,                  if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.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);
         }          }
 #endif /* PFIL_HOOKS */  #endif /* PFIL_HOOKS */
   
Line 466  ip6_input(m)
Line 466  ip6_input(m)
         if (ip6_forward_rt.ro_rt != NULL &&          if (ip6_forward_rt.ro_rt != NULL &&
             (ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 &&              (ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 &&
             IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,              IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,
                                &((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr))              &((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr))
                 ip6stat.ip6s_forward_cachehit++;                  ip6stat.ip6s_forward_cachehit++;
         else {          else {
                 struct sockaddr_in6 *dst6;                  struct sockaddr_in6 *dst6;
Line 541  ip6_input(m)
Line 541  ip6_input(m)
          */           */
 #if defined(NFAITH) && 0 < NFAITH  #if defined(NFAITH) && 0 < NFAITH
         if (ip6_keepfaith) {          if (ip6_keepfaith) {
                 if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp                  if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp &&
                  && ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) {                      ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) {
                         /* XXX do we need more sanity checks? */                          /* XXX do we need more sanity checks? */
                         ours = 1;                          ours = 1;
                         deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */                          deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */
Line 683  ip6_input(m)
Line 683  ip6_input(m)
                         return;                          return;
                 }                  }
         } else if (!ours) {          } else if (!ours) {
                 ip6_forward(m, 0);                  ip6_forward(m, srcrt);
                 return;                  return;
         }          }
   
Line 770  ip6_hopopts_input(plenp, rtalertp, mp, o
Line 770  ip6_hopopts_input(plenp, rtalertp, mp, o
         struct mbuf *m = *mp;          struct mbuf *m = *mp;
         int off = *offp, hbhlen;          int off = *offp, hbhlen;
         struct ip6_hbh *hbh;          struct ip6_hbh *hbh;
         u_int8_t *opt;  
   
         /* validation of the length of the header */          /* validation of the length of the header */
         IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,          IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,
Line 789  ip6_hopopts_input(plenp, rtalertp, mp, o
Line 788  ip6_hopopts_input(plenp, rtalertp, mp, o
         KASSERT(IP6_HDR_ALIGNED_P(hbh));          KASSERT(IP6_HDR_ALIGNED_P(hbh));
         off += hbhlen;          off += hbhlen;
         hbhlen -= sizeof(struct ip6_hbh);          hbhlen -= sizeof(struct ip6_hbh);
         opt = (u_int8_t *)hbh + sizeof(struct ip6_hbh);  
   
         if (ip6_process_hopopts(m, (u_int8_t *)hbh + sizeof(struct ip6_hbh),          if (ip6_process_hopopts(m, (u_int8_t *)hbh + sizeof(struct ip6_hbh),
                                 hbhlen, rtalertp, plenp) < 0)                                  hbhlen, rtalertp, plenp) < 0)
Line 999  ip6_savecontrol(in6p, mp, ip6, m)
Line 997  ip6_savecontrol(in6p, mp, ip6, m)
         struct ip6_hdr *ip6;          struct ip6_hdr *ip6;
         struct mbuf *m;          struct mbuf *m;
 {  {
         struct proc *p = curproc;       /* XXX */  
         int privileged;  
   
         privileged = 0;  
         if (p && !suser(p->p_ucred, &p->p_acflag))  
                 privileged++;  
   
 #ifdef SO_TIMESTAMP  #ifdef SO_TIMESTAMP
         if (in6p->in6p_socket->so_options & SO_TIMESTAMP) {          if (in6p->in6p_socket->so_options & SO_TIMESTAMP) {
Line 1012  ip6_savecontrol(in6p, mp, ip6, m)
Line 1004  ip6_savecontrol(in6p, mp, ip6, m)
   
                 microtime(&tv);                  microtime(&tv);
                 *mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),                  *mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),
                         SCM_TIMESTAMP, SOL_SOCKET);                      SCM_TIMESTAMP, SOL_SOCKET);
                 if (*mp)                  if (*mp)
                         mp = &(*mp)->m_next;                          mp = &(*mp)->m_next;
         }          }
 #endif  #endif
         if (in6p->in6p_flags & IN6P_RECVDSTADDR) {          if (in6p->in6p_flags & IN6P_RECVDSTADDR) {
                 *mp = sbcreatecontrol((caddr_t) &ip6->ip6_dst,                  *mp = sbcreatecontrol((caddr_t) &ip6->ip6_dst,
                         sizeof(struct in6_addr), IPV6_RECVDSTADDR,                      sizeof(struct in6_addr), IPV6_RECVDSTADDR, IPPROTO_IPV6);
                         IPPROTO_IPV6);  
                 if (*mp)                  if (*mp)
                         mp = &(*mp)->m_next;                          mp = &(*mp)->m_next;
         }          }
Line 1044  ip6_savecontrol(in6p, mp, ip6, m)
Line 1035  ip6_savecontrol(in6p, mp, ip6, m)
                                         ? m->m_pkthdr.rcvif->if_index                                          ? m->m_pkthdr.rcvif->if_index
                                         : 0;                                          : 0;
                 *mp = sbcreatecontrol((caddr_t) &pi6,                  *mp = sbcreatecontrol((caddr_t) &pi6,
                         sizeof(struct in6_pktinfo), IPV6_PKTINFO,                      sizeof(struct in6_pktinfo), IPV6_PKTINFO, IPPROTO_IPV6);
                         IPPROTO_IPV6);  
                 if (*mp)                  if (*mp)
                         mp = &(*mp)->m_next;                          mp = &(*mp)->m_next;
         }          }
         if (in6p->in6p_flags & IN6P_HOPLIMIT) {          if (in6p->in6p_flags & IN6P_HOPLIMIT) {
                 int hlim = ip6->ip6_hlim & 0xff;                  int hlim = ip6->ip6_hlim & 0xff;
                 *mp = sbcreatecontrol((caddr_t) &hlim,                  *mp = sbcreatecontrol((caddr_t) &hlim, sizeof(int),
                         sizeof(int), IPV6_HOPLIMIT, IPPROTO_IPV6);                      IPV6_HOPLIMIT, IPPROTO_IPV6);
                 if (*mp)                  if (*mp)
                         mp = &(*mp)->m_next;                          mp = &(*mp)->m_next;
         }          }
         /* IN6P_NEXTHOP - for outgoing packet only */          /* IN6P_NEXTHOP - for outgoing packet only */
   
         /*          /*
          * IPV6_HOPOPTS socket option. We require super-user privilege           * IPV6_HOPOPTS socket option.  Recall that we required super-user
          * for the option, but it might be too strict, since there might           * privilege for the option (see ip6_ctloutput), but it might be too
          * be some hop-by-hop options which can be returned to normal user.           * strict, since there might be some hop-by-hop options which can be
          * See RFC 2292 section 6.           * returned to normal user.
            * See also RFC 2292 section 6.
          */           */
         if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0 && privileged) {          if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0) {
                 /*                  /*
                  * Check if a hop-by-hop options header is contatined in the                   * Check if a hop-by-hop options header is contatined in the
                  * received packet, and if so, store the options as ancillary                   * received packet, and if so, store the options as ancillary
Line 1099  ip6_savecontrol(in6p, mp, ip6, m)
Line 1090  ip6_savecontrol(in6p, mp, ip6, m)
                          * But it's too painful operation...                           * But it's too painful operation...
                          */                           */
                         *mp = sbcreatecontrol((caddr_t)hbh, hbhlen,                          *mp = sbcreatecontrol((caddr_t)hbh, hbhlen,
                                               IPV6_HOPOPTS, IPPROTO_IPV6);                              IPV6_HOPOPTS, IPPROTO_IPV6);
                         if (*mp)                          if (*mp)
                                 mp = &(*mp)->m_next;                                  mp = &(*mp)->m_next;
                         m_freem(ext);                          m_freem(ext);
Line 1159  ip6_savecontrol(in6p, mp, ip6, m)
Line 1150  ip6_savecontrol(in6p, mp, ip6, m)
                                 if (!in6p->in6p_flags & IN6P_DSTOPTS)                                  if (!in6p->in6p_flags & IN6P_DSTOPTS)
                                         break;                                          break;
   
                                 /*  
                                  * We also require super-user privilege for  
                                  * the option.  
                                  * See the comments on IN6_HOPOPTS.  
                                  */  
                                 if (!privileged)  
                                         break;  
   
                                 *mp = sbcreatecontrol((caddr_t)ip6e, elen,                                  *mp = sbcreatecontrol((caddr_t)ip6e, elen,
                                                       IPV6_DSTOPTS,                                      IPV6_DSTOPTS, IPPROTO_IPV6);
                                                       IPPROTO_IPV6);  
                                 if (*mp)                                  if (*mp)
                                         mp = &(*mp)->m_next;                                          mp = &(*mp)->m_next;
                                 break;                                  break;
Line 1179  ip6_savecontrol(in6p, mp, ip6, m)
Line 1161  ip6_savecontrol(in6p, mp, ip6, m)
                                         break;                                          break;
   
                                 *mp = sbcreatecontrol((caddr_t)ip6e, elen,                                  *mp = sbcreatecontrol((caddr_t)ip6e, elen,
                                                       IPV6_RTHDR,                                      IPV6_RTHDR, IPPROTO_IPV6);
                                                       IPPROTO_IPV6);  
                                 if (*mp)                                  if (*mp)
                                         mp = &(*mp)->m_next;                                          mp = &(*mp)->m_next;
                                 break;                                  break;
Line 1355  ip6_nexthdr(m, off, proto, nxtp)
Line 1336  ip6_nexthdr(m, off, proto, nxtp)
                 if (m->m_pkthdr.len < off + sizeof(fh))                  if (m->m_pkthdr.len < off + sizeof(fh))
                         return -1;                          return -1;
                 m_copydata(m, off, sizeof(fh), (caddr_t)&fh);                  m_copydata(m, off, sizeof(fh), (caddr_t)&fh);
                 if ((ntohs(fh.ip6f_offlg) & IP6F_OFF_MASK) != 0)                  if ((fh.ip6f_offlg & IP6F_OFF_MASK) != 0)
                         return -1;                          return -1;
                 if (nxtp)                  if (nxtp)
                         *nxtp = fh.ip6f_nxt;                          *nxtp = fh.ip6f_nxt;
Line 1441  u_char inet6ctlerrmap[PRC_NCMDS] = {
Line 1422  u_char inet6ctlerrmap[PRC_NCMDS] = {
         ENOPROTOOPT          ENOPROTOOPT
 };  };
   
 int  SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup")
 ip6_sysctl(name, namelen, oldp, oldlenp, newp, newlen)  
         int *name;  
         u_int namelen;  
         void *oldp;  
         size_t *oldlenp;  
         void *newp;  
         size_t newlen;  
 {  {
         int old, error;  
   
         /* All sysctl names at this level are terminal. */          sysctl_createv(clog, 0, NULL, NULL,
         if (namelen != 1)                         CTLFLAG_PERMANENT,
                 return ENOTDIR;                         CTLTYPE_NODE, "net", NULL,
                          NULL, 0, NULL, 0,
         switch (name[0]) {                         CTL_NET, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
         case IPV6CTL_FORWARDING:                         CTLFLAG_PERMANENT,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         CTLTYPE_NODE, "inet6",
                                   &ip6_forwarding);                         SYSCTL_DESCR("PF_INET6 related settings"),
         case IPV6CTL_SENDREDIRECTS:                         NULL, 0, NULL, 0,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         CTL_NET, PF_INET6, CTL_EOL);
                                 &ip6_sendredirects);          sysctl_createv(clog, 0, NULL, NULL,
         case IPV6CTL_DEFHLIM:                         CTLFLAG_PERMANENT,
                 return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_defhlim);                         CTLTYPE_NODE, "ip6",
         case IPV6CTL_MAXFRAGPACKETS:                         SYSCTL_DESCR("IPv6 related settings"),
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         NULL, 0, NULL, 0,
                                 &ip6_maxfragpackets);                         CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_EOL);
         case IPV6CTL_ACCEPT_RTADV:  
                 return sysctl_int(oldp, oldlenp, newp, newlen,          sysctl_createv(clog, 0, NULL, NULL,
                                 &ip6_accept_rtadv);                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
         case IPV6CTL_KEEPFAITH:                         CTLTYPE_INT, "forwarding",
                 return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_keepfaith);                         SYSCTL_DESCR("Enable forwarding of INET6 datagrams"),
         case IPV6CTL_LOG_INTERVAL:                         NULL, 0, &ip6_forwarding, 0,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                                 &ip6_log_interval);                         IPV6CTL_FORWARDING, CTL_EOL);
         case IPV6CTL_HDRNESTLIMIT:          sysctl_createv(clog, 0, NULL, NULL,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                                 &ip6_hdrnestlimit);                         CTLTYPE_INT, "redirect",
         case IPV6CTL_DAD_COUNT:                         SYSCTL_DESCR("Enable sending of ICMPv6 redirect messages"),
                 return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_dad_count);                         NULL, 0, &ip6_sendredirects, 0,
         case IPV6CTL_AUTO_FLOWLABEL:                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         IPV6CTL_SENDREDIRECTS, CTL_EOL);
                                 &ip6_auto_flowlabel);          sysctl_createv(clog, 0, NULL, NULL,
         case IPV6CTL_DEFMCASTHLIM:                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         CTLTYPE_INT, "hlim",
                                 &ip6_defmcasthlim);                         SYSCTL_DESCR("Hop limit for an INET6 datagram"),
                          NULL, 0, &ip6_defhlim, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_DEFHLIM, CTL_EOL);
   #ifdef notyet
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "mtu", NULL,
                          NULL, 0, &, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_DEFMTU, CTL_EOL);
   #endif
   #ifdef __no_idea__
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "forwsrcrt", NULL,
                          NULL, 0, &?, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_FORWSRCRT, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_STRUCT, "stats", NULL,
                          NULL, 0, &?, sizeof(?),
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_STATS, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_STRUCT, "mrtstats", NULL,
                          NULL, 0, &?, sizeof(?),
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_MRTSTATS, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_?, "mrtproto", NULL,
                          NULL, 0, &?, sizeof(?),
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_MRTPROTO, CTL_EOL);
   #endif
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "maxfragpackets",
                          SYSCTL_DESCR("Maximum number of fragments to buffer "
                                       "for reassembly"),
                          NULL, 0, &ip6_maxfragpackets, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_MAXFRAGPACKETS, CTL_EOL);
   #ifdef __no_idea__
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "sourcecheck", NULL,
                          NULL, 0, &?, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_SOURCECHECK, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "sourcecheck_logint", NULL,
                          NULL, 0, &?, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_SOURCECHECK_LOGINT, CTL_EOL);
   #endif
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "accept_rtadv",
                          SYSCTL_DESCR("Accept router advertisements"),
                          NULL, 0, &ip6_accept_rtadv, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_ACCEPT_RTADV, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "keepfaith",
                          SYSCTL_DESCR("Activate faith interface"),
                          NULL, 0, &ip6_keepfaith, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_KEEPFAITH, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "log_interval",
                          SYSCTL_DESCR("Minumum interval between logging "
                                       "unroutable packets"),
                          NULL, 0, &ip6_log_interval, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_LOG_INTERVAL, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "hdrnestlimit",
                          SYSCTL_DESCR("Maximum number of nested IPv6 headers"),
                          NULL, 0, &ip6_hdrnestlimit, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_HDRNESTLIMIT, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "dad_count",
                          SYSCTL_DESCR("Number of Duplicate Address Detection "
                                       "probes to send"),
                          NULL, 0, &ip6_dad_count, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_DAD_COUNT, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "auto_flowlabel",
                          SYSCTL_DESCR("Assign random IPv6 flow labels"),
                          NULL, 0, &ip6_auto_flowlabel, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_AUTO_FLOWLABEL, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "defmcasthlim",
                          SYSCTL_DESCR("Default multicast hop limit"),
                          NULL, 0, &ip6_defmcasthlim, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_DEFMCASTHLIM, CTL_EOL);
 #if NGIF > 0  #if NGIF > 0
         case IPV6CTL_GIF_HLIM:          sysctl_createv(clog, 0, NULL, NULL,
                 return sysctl_int(oldp, oldlenp, newp, newlen,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                                 &ip6_gif_hlim);                         CTLTYPE_INT, "gifhlim",
 #endif                         SYSCTL_DESCR("Default hop limit for a gif tunnel datagram"),
         case IPV6CTL_KAME_VERSION:                         NULL, 0, &ip6_gif_hlim, 0,
                 return sysctl_rdstring(oldp, oldlenp, newp, __KAME_VERSION);                         CTL_NET, PF_INET6, IPPROTO_IPV6,
         case IPV6CTL_USE_DEPRECATED:                         IPV6CTL_GIF_HLIM, CTL_EOL);
                 return sysctl_int(oldp, oldlenp, newp, newlen,  #endif /* NGIF */
                                 &ip6_use_deprecated);          sysctl_createv(clog, 0, NULL, NULL,
         case IPV6CTL_RR_PRUNE:                         CTLFLAG_PERMANENT,
                 return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_rr_prune);                         CTLTYPE_STRING, "kame_version",
         case IPV6CTL_V6ONLY:                         SYSCTL_DESCR("KAME Version"),
 #ifdef INET6_BINDV6ONLY                         NULL, 0, __KAME_VERSION, 0,
                 return sysctl_rdint(oldp, oldlenp, newp, ip6_v6only);                         CTL_NET, PF_INET6, IPPROTO_IPV6,
 #else                         IPV6CTL_KAME_VERSION, CTL_EOL);
                 return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_v6only);          sysctl_createv(clog, 0, NULL, NULL,
 #endif                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
         case IPV6CTL_ANONPORTMIN:                         CTLTYPE_INT, "use_deprecated",
                 old = ip6_anonportmin;                         SYSCTL_DESCR("Allow use of deprecated addresses as "
                 error = sysctl_int(oldp, oldlenp, newp, newlen,                                      "source addresses"),
                     &ip6_anonportmin);                         NULL, 0, &ip6_use_deprecated, 0,
                 if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmin < 0 ||                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                     ip6_anonportmin > 65535                         IPV6CTL_USE_DEPRECATED, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "rr_prune", NULL,
                          NULL, 0, &ip6_rr_prune, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_RR_PRUNE, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT
   #ifndef INET6_BINDV6ONLY
                          |CTLFLAG_READWRITE,
   #endif
                          CTLTYPE_INT, "v6only",
                          SYSCTL_DESCR("Disallow PF_INET6 sockets from connecting "
                                       "to PF_INET sockets"),
                          NULL, 0, &ip6_v6only, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_V6ONLY, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "anonportmin",
                          SYSCTL_DESCR("Lowest ephemeral port number to assign"),
                          sysctl_net_inet_ip_ports, 0, &ip6_anonportmin, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_ANONPORTMIN, CTL_EOL);
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "anonportmax",
                          SYSCTL_DESCR("Highest ephemeral port number to assign"),
                          sysctl_net_inet_ip_ports, 0, &ip6_anonportmax, 0,
                          CTL_NET, PF_INET6, IPPROTO_IPV6,
                          IPV6CTL_ANONPORTMAX, CTL_EOL);
 #ifndef IPNOPRIVPORTS  #ifndef IPNOPRIVPORTS
                     || ip6_anonportmin < IPV6PORT_RESERVED          sysctl_createv(clog, 0, NULL, NULL,
 #endif                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                     ) {                         CTLTYPE_INT, "lowportmin",
                         ip6_anonportmin = old;                         SYSCTL_DESCR("Lowest privileged ephemeral port number "
                         return (EINVAL);                                      "to assign"),
                 }                         sysctl_net_inet_ip_ports, 0, &ip6_lowportmin, 0,
                 return (error);                         CTL_NET, PF_INET6, IPPROTO_IPV6,
         case IPV6CTL_ANONPORTMAX:                         IPV6CTL_LOWPORTMIN, CTL_EOL);
                 old = ip6_anonportmax;          sysctl_createv(clog, 0, NULL, NULL,
                 error = sysctl_int(oldp, oldlenp, newp, newlen,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                     &ip6_anonportmax);                         CTLTYPE_INT, "lowportmax",
                 if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmax < 0 ||                         SYSCTL_DESCR("Highest privileged ephemeral port number "
                     ip6_anonportmax > 65535                                      "to assign"),
 #ifndef IPNOPRIVPORTS                         sysctl_net_inet_ip_ports, 0, &ip6_lowportmax, 0,
                     || ip6_anonportmax < IPV6PORT_RESERVED                         CTL_NET, PF_INET6, IPPROTO_IPV6,
 #endif                         IPV6CTL_LOWPORTMAX, CTL_EOL);
                     ) {  #endif /* IPNOPRIVPORTS */
                         ip6_anonportmax = old;          sysctl_createv(clog, 0, NULL, NULL,
                         return (EINVAL);                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                 }                         CTLTYPE_INT, "maxfrags",
                 return (error);                         SYSCTL_DESCR("Maximum fragments in reassembly queue"),
 #ifndef IPNOPRIVPORTS                         NULL, 0, &ip6_maxfrags, 0,
         case IPV6CTL_LOWPORTMIN:                         CTL_NET, PF_INET6, IPPROTO_IPV6,
                 old = ip6_lowportmin;                         IPV6CTL_MAXFRAGS, CTL_EOL);
                 error = sysctl_int(oldp, oldlenp, newp, newlen,  
                     &ip6_lowportmin);  
                 if (ip6_lowportmin >= ip6_lowportmax ||  
                     ip6_lowportmin > IPV6PORT_RESERVEDMAX ||  
                     ip6_lowportmin < IPV6PORT_RESERVEDMIN) {  
                         ip6_lowportmin = old;  
                         return (EINVAL);  
                 }  
                 return (error);  
         case IPV6CTL_LOWPORTMAX:  
                 old = ip6_lowportmax;  
                 error = sysctl_int(oldp, oldlenp, newp, newlen,  
                     &ip6_lowportmax);  
                 if (ip6_lowportmin >= ip6_lowportmax ||  
                     ip6_lowportmax > IPV6PORT_RESERVEDMAX ||  
                     ip6_lowportmax < IPV6PORT_RESERVEDMIN) {  
                         ip6_lowportmax = old;  
                         return (EINVAL);  
                 }  
                 return (error);  
 #endif  
         case IPV6CTL_MAXFRAGS:  
                 return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_maxfrags);  
         default:  
                 return EOPNOTSUPP;  
         }  
         /* NOTREACHED */  
 }  }
Legend:
Removed from v.1.62  
changed lines
  Added in v.1.64.2.1
CVSweb <webmaster@jp.NetBSD.org>