[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.64.2.6 and 1.65

version 1.64.2.6, 2005/11/10 14:11:25 version 1.65, 2003/08/07 16:33:26
Line 112  __KERNEL_RCSID(0, "$NetBSD$");
Line 112  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include <netinet6/ip6protosw.h>  #include <netinet6/ip6protosw.h>
   
   /* we need it for NLOOP. */
   #include "loop.h"
 #include "faith.h"  #include "faith.h"
 #include "gif.h"  #include "gif.h"
   #include "bpfilter.h"
   
 #if NGIF > 0  #if NGIF > 0
 #include <netinet6/in6_gif.h>  #include <netinet6/in6_gif.h>
Line 128  static int ip6qmaxlen = IFQ_MAXLEN;
Line 131  static int ip6qmaxlen = IFQ_MAXLEN;
 struct in6_ifaddr *in6_ifaddr;  struct in6_ifaddr *in6_ifaddr;
 struct ifqueue ip6intrq;  struct ifqueue ip6intrq;
   
   extern struct ifnet loif[NLOOP];
 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 */
Line 150  static struct mbuf *ip6_pullexthdr __P((
Line 154  static struct mbuf *ip6_pullexthdr __P((
 void  void
 ip6_init()  ip6_init()
 {  {
         const struct ip6protosw *pr;          struct ip6protosw *pr;
         int i;          int i;
   
         pr = (const struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);          pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);
         if (pr == 0)          if (pr == 0)
                 panic("ip6_init");                  panic("ip6_init");
         for (i = 0; i < IPPROTO_MAX; i++)          for (i = 0; i < IPPROTO_MAX; i++)
                 ip6_protox[i] = pr - inet6sw;                  ip6_protox[i] = pr - inet6sw;
         for (pr = (const struct ip6protosw *)inet6domain.dom_protosw;          for (pr = (struct ip6protosw *)inet6domain.dom_protosw;
             pr < (const struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++)              pr < (struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++)
                 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;          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 244  ip6_input(m)
Line 249  ip6_input(m)
 #define M2MMAX  (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0]))  #define M2MMAX  (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0]))
                 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 */                                  ip6stat.ip6s_m2m[loif[0].if_index]++; /* XXX */
                         } else if (m->m_pkthdr.rcvif->if_index < M2MMAX)                          } else if (m->m_pkthdr.rcvif->if_index < M2MMAX)
                                 ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++;                                  ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++;
                         else                          else
Line 462  ip6_input(m)
Line 467  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 537  ip6_input(m)
Line 542  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 766  ip6_hopopts_input(plenp, rtalertp, mp, o
Line 771  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 784  ip6_hopopts_input(plenp, rtalertp, mp, o
Line 790  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 993  ip6_savecontrol(in6p, mp, ip6, m)
Line 1000  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 1045  ip6_savecontrol(in6p, mp, ip6, m)
Line 1058  ip6_savecontrol(in6p, mp, ip6, m)
         /* IN6P_NEXTHOP - for outgoing packet only */          /* IN6P_NEXTHOP - for outgoing packet only */
   
         /*          /*
          * IPV6_HOPOPTS socket option.  Recall that we required super-user           * IPV6_HOPOPTS socket option. We require super-user privilege
          * privilege for the option (see ip6_ctloutput), but it might be too           * for the option, but it might be too strict, since there might
          * strict, since there might be some hop-by-hop options which can be           * be some hop-by-hop options which can be returned to normal user.
          * returned to normal user.           * See RFC 2292 section 6.
          * See also RFC 2292 section 6.  
          */           */
         if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0) {          if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0 && privileged) {
                 /*                  /*
                  * 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 1059  ip6_savecontrol(in6p, mp, ip6, m)
Line 1071  ip6_savecontrol(in6p, mp, ip6, m)
                  * just after the IPv6 header, which fact is assured through                   * just after the IPv6 header, which fact is assured through
                  * the IPv6 input processing.                   * the IPv6 input processing.
                  */                   */
                 struct ip6_hdr *xip6 = mtod(m, struct ip6_hdr *);                  struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
                 if (xip6->ip6_nxt == IPPROTO_HOPOPTS) {                  if (ip6->ip6_nxt == IPPROTO_HOPOPTS) {
                         struct ip6_hbh *hbh;                          struct ip6_hbh *hbh;
                         int hbhlen;                          int hbhlen;
                         struct mbuf *ext;                          struct mbuf *ext;
   
                         ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr),                          ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr),
                             xip6->ip6_nxt);                              ip6->ip6_nxt);
                         if (ext == NULL) {                          if (ext == NULL) {
                                 ip6stat.ip6s_tooshort++;                                  ip6stat.ip6s_tooshort++;
                                 return;                                  return;
Line 1095  ip6_savecontrol(in6p, mp, ip6, m)
Line 1107  ip6_savecontrol(in6p, mp, ip6, m)
   
         /* IPV6_DSTOPTS and IPV6_RTHDR socket options */          /* IPV6_DSTOPTS and IPV6_RTHDR socket options */
         if (in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) {          if (in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) {
                 struct ip6_hdr *xip6 = mtod(m, struct ip6_hdr *);                  struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
                 int nxt = xip6->ip6_nxt, off = sizeof(struct ip6_hdr);                  int nxt = ip6->ip6_nxt, off = sizeof(struct ip6_hdr);
   
                 /*                  /*
                  * Search for destination options headers or routing                   * Search for destination options headers or routing
Line 1146  ip6_savecontrol(in6p, mp, ip6, m)
Line 1158  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, IPPROTO_IPV6);                                      IPV6_DSTOPTS, IPPROTO_IPV6);
                                 if (*mp)                                  if (*mp)
Line 1332  ip6_nexthdr(m, off, proto, nxtp)
Line 1352  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 ((fh.ip6f_offlg & IP6F_OFF_MASK) != 0)                  if ((ntohs(fh.ip6f_offlg) & IP6F_OFF_MASK) != 0)
                         return -1;                          return -1;
                 if (nxtp)                  if (nxtp)
                         *nxtp = fh.ip6f_nxt;                          *nxtp = fh.ip6f_nxt;
Line 1418  u_char inet6ctlerrmap[PRC_NCMDS] = {
Line 1438  u_char inet6ctlerrmap[PRC_NCMDS] = {
         ENOPROTOOPT          ENOPROTOOPT
 };  };
   
 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup")  int
   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;
   
         sysctl_createv(clog, 0, NULL, NULL,          /* All sysctl names at this level are terminal. */
                        CTLFLAG_PERMANENT,          if (namelen != 1)
                        CTLTYPE_NODE, "net", NULL,                  return ENOTDIR;
                        NULL, 0, NULL, 0,  
                        CTL_NET, CTL_EOL);          switch (name[0]) {
         sysctl_createv(clog, 0, NULL, NULL,  
                        CTLFLAG_PERMANENT,          case IPV6CTL_FORWARDING:
                        CTLTYPE_NODE, "inet6",                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        SYSCTL_DESCR("PF_INET6 related settings"),                                    &ip6_forwarding);
                        NULL, 0, NULL, 0,          case IPV6CTL_SENDREDIRECTS:
                        CTL_NET, PF_INET6, CTL_EOL);                  return sysctl_int(oldp, oldlenp, newp, newlen,
         sysctl_createv(clog, 0, NULL, NULL,                                  &ip6_sendredirects);
                        CTLFLAG_PERMANENT,          case IPV6CTL_DEFHLIM:
                        CTLTYPE_NODE, "ip6",                  return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_defhlim);
                        SYSCTL_DESCR("IPv6 related settings"),          case IPV6CTL_MAXFRAGPACKETS:
                        NULL, 0, NULL, 0,                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_EOL);                                  &ip6_maxfragpackets);
           case IPV6CTL_ACCEPT_RTADV:
         sysctl_createv(clog, 0, NULL, NULL,                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                                  &ip6_accept_rtadv);
                        CTLTYPE_INT, "forwarding",          case IPV6CTL_KEEPFAITH:
                        SYSCTL_DESCR("Enable forwarding of INET6 datagrams"),                  return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_keepfaith);
                        NULL, 0, &ip6_forwarding, 0,          case IPV6CTL_LOG_INTERVAL:
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        IPV6CTL_FORWARDING, CTL_EOL);                                  &ip6_log_interval);
         sysctl_createv(clog, 0, NULL, NULL,          case IPV6CTL_HDRNESTLIMIT:
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        CTLTYPE_INT, "redirect",                                  &ip6_hdrnestlimit);
                        SYSCTL_DESCR("Enable sending of ICMPv6 redirect messages"),          case IPV6CTL_DAD_COUNT:
                        NULL, 0, &ip6_sendredirects, 0,                  return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_dad_count);
                        CTL_NET, PF_INET6, IPPROTO_IPV6,          case IPV6CTL_AUTO_FLOWLABEL:
                        IPV6CTL_SENDREDIRECTS, CTL_EOL);                  return sysctl_int(oldp, oldlenp, newp, newlen,
         sysctl_createv(clog, 0, NULL, NULL,                                  &ip6_auto_flowlabel);
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,          case IPV6CTL_DEFMCASTHLIM:
                        CTLTYPE_INT, "hlim",                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        SYSCTL_DESCR("Hop limit for an INET6 datagram"),                                  &ip6_defmcasthlim);
                        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, "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
         sysctl_createv(clog, 0, NULL, NULL,          case IPV6CTL_GIF_HLIM:
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                  return sysctl_int(oldp, oldlenp, newp, newlen,
                        CTLTYPE_INT, "gifhlim",                                  &ip6_gif_hlim);
                        SYSCTL_DESCR("Default hop limit for a gif tunnel datagram"),  #endif
                        NULL, 0, &ip6_gif_hlim, 0,          case IPV6CTL_KAME_VERSION:
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                  return sysctl_rdstring(oldp, oldlenp, newp, __KAME_VERSION);
                        IPV6CTL_GIF_HLIM, CTL_EOL);          case IPV6CTL_USE_DEPRECATED:
 #endif /* NGIF */                  return sysctl_int(oldp, oldlenp, newp, newlen,
         sysctl_createv(clog, 0, NULL, NULL,                                  &ip6_use_deprecated);
                        CTLFLAG_PERMANENT,          case IPV6CTL_RR_PRUNE:
                        CTLTYPE_STRING, "kame_version",                  return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_rr_prune);
                        SYSCTL_DESCR("KAME Version"),          case IPV6CTL_V6ONLY:
                        NULL, 0, __UNCONST(__KAME_VERSION), 0,  #ifdef INET6_BINDV6ONLY
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                  return sysctl_rdint(oldp, oldlenp, newp, ip6_v6only);
                        IPV6CTL_KAME_VERSION, CTL_EOL);  #else
         sysctl_createv(clog, 0, NULL, NULL,                  return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_v6only);
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,  #endif
                        CTLTYPE_INT, "use_deprecated",          case IPV6CTL_ANONPORTMIN:
                        SYSCTL_DESCR("Allow use of deprecated addresses as "                  old = ip6_anonportmin;
                                     "source addresses"),                  error = sysctl_int(oldp, oldlenp, newp, newlen,
                        NULL, 0, &ip6_use_deprecated, 0,                      &ip6_anonportmin);
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                  if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmin < 0 ||
                        IPV6CTL_USE_DEPRECATED, CTL_EOL);                      ip6_anonportmin > 65535
         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
         sysctl_createv(clog, 0, NULL, NULL,                      || ip6_anonportmin < IPV6PORT_RESERVED
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,  #endif
                        CTLTYPE_INT, "lowportmin",                      ) {
                        SYSCTL_DESCR("Lowest privileged ephemeral port number "                          ip6_anonportmin = old;
                                     "to assign"),                          return (EINVAL);
                        sysctl_net_inet_ip_ports, 0, &ip6_lowportmin, 0,                  }
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                  return (error);
                        IPV6CTL_LOWPORTMIN, CTL_EOL);          case IPV6CTL_ANONPORTMAX:
         sysctl_createv(clog, 0, NULL, NULL,                  old = ip6_anonportmax;
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                  error = sysctl_int(oldp, oldlenp, newp, newlen,
                        CTLTYPE_INT, "lowportmax",                      &ip6_anonportmax);
                        SYSCTL_DESCR("Highest privileged ephemeral port number "                  if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmax < 0 ||
                                     "to assign"),                      ip6_anonportmax > 65535
                        sysctl_net_inet_ip_ports, 0, &ip6_lowportmax, 0,  #ifndef IPNOPRIVPORTS
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                      || ip6_anonportmax < IPV6PORT_RESERVED
                        IPV6CTL_LOWPORTMAX, CTL_EOL);  #endif
 #endif /* IPNOPRIVPORTS */                      ) {
         sysctl_createv(clog, 0, NULL, NULL,                          ip6_anonportmax = old;
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                          return (EINVAL);
                        CTLTYPE_INT, "maxfrags",                  }
                        SYSCTL_DESCR("Maximum fragments in reassembly queue"),                  return (error);
                        NULL, 0, &ip6_maxfrags, 0,  #ifndef IPNOPRIVPORTS
                        CTL_NET, PF_INET6, IPPROTO_IPV6,          case IPV6CTL_LOWPORTMIN:
                        IPV6CTL_MAXFRAGS, CTL_EOL);                  old = ip6_lowportmin;
         sysctl_createv(clog, 0, NULL, NULL,                  error = sysctl_int(oldp, oldlenp, newp, newlen,
                        CTLFLAG_PERMANENT,                      &ip6_lowportmin);
                        CTLTYPE_STRUCT, "stats",                  if (ip6_lowportmin >= ip6_lowportmax ||
                        SYSCTL_DESCR("IPv6 statistics"),                      ip6_lowportmin > IPV6PORT_RESERVEDMAX ||
                        NULL, 0, &ip6stat, sizeof(ip6stat),                      ip6_lowportmin < IPV6PORT_RESERVEDMIN) {
                        CTL_NET, PF_INET6, IPPROTO_IPV6,                          ip6_lowportmin = old;
                        IPV6CTL_STATS, CTL_EOL);                          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.64.2.6  
changed lines
  Added in v.1.65
CVSweb <webmaster@jp.NetBSD.org>