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

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

Diff for /src/sys/netinet/ip_input.c between version 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 1993/03/21 09:45:37 version 1.1.1.2, 1998/01/05 09:54:10
Line 1 
Line 1 
 /*  /*
  * Copyright (c) 1982, 1986, 1988 Regents of the University of California.   * Copyright (c) 1982, 1986, 1988, 1993
  * All rights reserved.   *      The Regents of the University of California.  All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions   * modification, are permitted provided that the following conditions
Line 30 
Line 30 
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.   * SUCH DAMAGE.
  *   *
  *      @(#)ip_input.c  7.19 (Berkeley) 5/25/91   *      @(#)ip_input.c  8.2 (Berkeley) 1/4/94
  */   */
   
 #include "param.h"  #include <sys/param.h>
 #include "systm.h"  #include <sys/systm.h>
 #include "malloc.h"  #include <sys/malloc.h>
 #include "mbuf.h"  #include <sys/mbuf.h>
 #include "domain.h"  #include <sys/domain.h>
 #include "protosw.h"  #include <sys/protosw.h>
 #include "socket.h"  #include <sys/socket.h>
 #include "errno.h"  #include <sys/errno.h>
 #include "time.h"  #include <sys/time.h>
 #include "kernel.h"  #include <sys/kernel.h>
   
 #include "../net/if.h"  #include <net/if.h>
 #include "../net/route.h"  #include <net/route.h>
   
 #include "in.h"  #include <netinet/in.h>
 #include "in_systm.h"  #include <netinet/in_systm.h>
 #include "ip.h"  #include <netinet/ip.h>
 #include "in_pcb.h"  #include <netinet/in_pcb.h>
 #include "in_var.h"  #include <netinet/in_var.h>
 #include "ip_var.h"  #include <netinet/ip_var.h>
 #include "ip_icmp.h"  #include <netinet/ip_icmp.h>
   
 #ifndef IPFORWARDING  #ifndef IPFORWARDING
 #ifdef GATEWAY  #ifdef GATEWAY
Line 67 
Line 67 
 #endif  #endif
 int     ipforwarding = IPFORWARDING;  int     ipforwarding = IPFORWARDING;
 int     ipsendredirects = IPSENDREDIRECTS;  int     ipsendredirects = IPSENDREDIRECTS;
   int     ip_defttl = IPDEFTTL;
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
 int     ipprintfs = 0;  int     ipprintfs = 0;
 #endif  #endif
Line 76  extern struct protosw inetsw[];
Line 77  extern struct protosw inetsw[];
 u_char  ip_protox[IPPROTO_MAX];  u_char  ip_protox[IPPROTO_MAX];
 int     ipqmaxlen = IFQ_MAXLEN;  int     ipqmaxlen = IFQ_MAXLEN;
 struct  in_ifaddr *in_ifaddr;                   /* first inet address */  struct  in_ifaddr *in_ifaddr;                   /* first inet address */
   struct  ifqueue ipintrq;
   
 /*  /*
  * We need to save the IP options in case a protocol wants to respond   * We need to save the IP options in case a protocol wants to respond
Line 97  extern int if_index;
Line 99  extern int if_index;
 u_long  *ip_ifmatrix;  u_long  *ip_ifmatrix;
 #endif  #endif
   
   static void save_rte __P((u_char *, struct in_addr));
 /*  /*
  * IP initialization: fill in IP protocol switch table.   * IP initialization: fill in IP protocol switch table.
  * All protocols not implemented in kernel go to raw IP protocol handler.   * All protocols not implemented in kernel go to raw IP protocol handler.
  */   */
   void
 ip_init()  ip_init()
 {  {
         register struct protosw *pr;          register struct protosw *pr;
Line 121  ip_init()
Line 125  ip_init()
         ipintrq.ifq_maxlen = ipqmaxlen;          ipintrq.ifq_maxlen = ipqmaxlen;
 #ifdef GATEWAY  #ifdef GATEWAY
         i = (if_index + 1) * (if_index + 1) * sizeof (u_long);          i = (if_index + 1) * (if_index + 1) * sizeof (u_long);
         if ((ip_ifmatrix = (u_long *) malloc(i, M_RTABLE, M_WAITOK)) == 0)          ip_ifmatrix = (u_long *) malloc(i, M_RTABLE, M_WAITOK);
                 panic("no memory for ip_ifmatrix");          bzero((char *)ip_ifmatrix, i);
 #endif  #endif
 }  }
   
 struct  ip *ip_reass();  
 struct  sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };  struct  sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };
 struct  route ipforward_rt;  struct  route ipforward_rt;
   
Line 134  struct route ipforward_rt;
Line 137  struct route ipforward_rt;
  * Ip input routine.  Checksum and byte swap header.  If fragmented   * Ip input routine.  Checksum and byte swap header.  If fragmented
  * try to reassemble.  Process options.  Pass to next level.   * try to reassemble.  Process options.  Pass to next level.
  */   */
   void
 ipintr()  ipintr()
 {  {
         register struct ip *ip;          register struct ip *ip;
Line 169  next:
Line 173  next:
                 goto next;                  goto next;
         }          }
         ip = mtod(m, struct ip *);          ip = mtod(m, struct ip *);
           if (ip->ip_v != IPVERSION) {
                   ipstat.ips_badvers++;
                   goto bad;
           }
         hlen = ip->ip_hl << 2;          hlen = ip->ip_hl << 2;
         if (hlen < sizeof(struct ip)) { /* minimum header length */          if (hlen < sizeof(struct ip)) { /* minimum header length */
                 ipstat.ips_badhlen++;                  ipstat.ips_badhlen++;
Line 256  next:
Line 264  next:
                                 goto ours;                                  goto ours;
                 }                  }
         }          }
           if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
                   struct in_multi *inm;
   #ifdef MROUTING
                   extern struct socket *ip_mrouter;
   
                   if (ip_mrouter) {
                           /*
                            * If we are acting as a multicast router, all
                            * incoming multicast packets are passed to the
                            * kernel-level multicast forwarding function.
                            * The packet is returned (relatively) intact; if
                            * ip_mforward() returns a non-zero value, the packet
                            * must be discarded, else it may be accepted below.
                            *
                            * (The IP ident field is put in the same byte order
                            * as expected when ip_mforward() is called from
                            * ip_output().)
                            */
                           ip->ip_id = htons(ip->ip_id);
                           if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {
                                   ipstat.ips_cantforward++;
                                   m_freem(m);
                                   goto next;
                           }
                           ip->ip_id = ntohs(ip->ip_id);
   
                           /*
                            * The process-level routing demon needs to receive
                            * all multicast IGMP packets, whether or not this
                            * host belongs to their destination groups.
                            */
                           if (ip->ip_p == IPPROTO_IGMP)
                                   goto ours;
                           ipstat.ips_forward++;
                   }
   #endif
                   /*
                    * See if we belong to the destination multicast group on the
                    * arrival interface.
                    */
                   IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);
                   if (inm == NULL) {
                           ipstat.ips_cantforward++;
                           m_freem(m);
                           goto next;
                   }
                   goto ours;
           }
         if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)          if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)
                 goto ours;                  goto ours;
         if (ip->ip_dst.s_addr == INADDR_ANY)          if (ip->ip_dst.s_addr == INADDR_ANY)
Line 306  found:
Line 362  found:
                  * convert offset of this to bytes.                   * convert offset of this to bytes.
                  */                   */
                 ip->ip_len -= hlen;                  ip->ip_len -= hlen;
                 ((struct ipasfrag *)ip)->ipf_mff = 0;                  ((struct ipasfrag *)ip)->ipf_mff &= ~1;
                 if (ip->ip_off & IP_MF)                  if (ip->ip_off & IP_MF)
                         ((struct ipasfrag *)ip)->ipf_mff = 1;                          ((struct ipasfrag *)ip)->ipf_mff |= 1;
                 ip->ip_off <<= 3;                  ip->ip_off <<= 3;
   
                 /*                  /*
Line 316  found:
Line 372  found:
                  * or if this is not the first fragment,                   * or if this is not the first fragment,
                  * attempt reassembly; if it succeeds, proceed.                   * attempt reassembly; if it succeeds, proceed.
                  */                   */
                 if (((struct ipasfrag *)ip)->ipf_mff || ip->ip_off) {                  if (((struct ipasfrag *)ip)->ipf_mff & 1 || ip->ip_off) {
                         ipstat.ips_fragments++;                          ipstat.ips_fragments++;
                         ip = ip_reass((struct ipasfrag *)ip, fp);                          ip = ip_reass((struct ipasfrag *)ip, fp);
                         if (ip == 0)                          if (ip == 0)
                                 goto next;                                  goto next;
                         else                          ipstat.ips_reassembled++;
                                 ipstat.ips_reassembled++;  
                         m = dtom(ip);                          m = dtom(ip);
                 } else                  } else
                         if (fp)                          if (fp)
Line 435  insert:
Line 490  insert:
                         return (0);                          return (0);
                 next += q->ip_len;                  next += q->ip_len;
         }          }
         if (q->ipf_prev->ipf_mff)          if (q->ipf_prev->ipf_mff & 1)
                 return (0);                  return (0);
   
         /*          /*
Line 461  insert:
Line 516  insert:
          */           */
         ip = fp->ipq_next;          ip = fp->ipq_next;
         ip->ip_len = next;          ip->ip_len = next;
           ip->ipf_mff &= ~1;
         ((struct ip *)ip)->ip_src = fp->ipq_src;          ((struct ip *)ip)->ip_src = fp->ipq_src;
         ((struct ip *)ip)->ip_dst = fp->ipq_dst;          ((struct ip *)ip)->ip_dst = fp->ipq_dst;
         remque(fp);          remque(fp);
Line 487  dropfrag:
Line 543  dropfrag:
  * Free a fragment reassembly header and all   * Free a fragment reassembly header and all
  * associated datagrams.   * associated datagrams.
  */   */
   void
 ip_freef(fp)  ip_freef(fp)
         struct ipq *fp;          struct ipq *fp;
 {  {
Line 505  ip_freef(fp)
Line 562  ip_freef(fp)
  * Put an ip fragment on a reassembly chain.   * Put an ip fragment on a reassembly chain.
  * Like insque, but pointers in middle of structure.   * Like insque, but pointers in middle of structure.
  */   */
   void
 ip_enq(p, prev)  ip_enq(p, prev)
         register struct ipasfrag *p, *prev;          register struct ipasfrag *p, *prev;
 {  {
Line 518  ip_enq(p, prev)
Line 576  ip_enq(p, prev)
 /*  /*
  * To ip_enq as remque is to insque.   * To ip_enq as remque is to insque.
  */   */
   void
 ip_deq(p)  ip_deq(p)
         register struct ipasfrag *p;          register struct ipasfrag *p;
 {  {
Line 531  ip_deq(p)
Line 590  ip_deq(p)
  * if a timer expires on a reassembly   * if a timer expires on a reassembly
  * queue, discard it.   * queue, discard it.
  */   */
   void
 ip_slowtimo()  ip_slowtimo()
 {  {
         register struct ipq *fp;          register struct ipq *fp;
Line 555  ip_slowtimo()
Line 615  ip_slowtimo()
 /*  /*
  * Drain off all datagram fragments.   * Drain off all datagram fragments.
  */   */
   void
 ip_drain()  ip_drain()
 {  {
   
Line 564  ip_drain()
Line 625  ip_drain()
         }          }
 }  }
   
 extern struct in_ifaddr *ifptoia();  
 struct in_ifaddr *ip_rtaddr();  
   
 /*  /*
  * Do option processing on a datagram,   * Do option processing on a datagram,
  * possibly discarding it if bad options are encountered,   * possibly discarding it if bad options are encountered,
Line 574  struct in_ifaddr *ip_rtaddr();
Line 632  struct in_ifaddr *ip_rtaddr();
  * Returns 1 if packet has been forwarded/freed,   * Returns 1 if packet has been forwarded/freed,
  * 0 if the packet should be processed further.   * 0 if the packet should be processed further.
  */   */
   int
 ip_dooptions(m)  ip_dooptions(m)
         struct mbuf *m;          struct mbuf *m;
 {  {
Line 582  ip_dooptions(m)
Line 641  ip_dooptions(m)
         register struct ip_timestamp *ipt;          register struct ip_timestamp *ipt;
         register struct in_ifaddr *ia;          register struct in_ifaddr *ia;
         int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;          int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;
         struct in_addr *sin;          struct in_addr *sin, dst;
         n_time ntime;          n_time ntime;
   
           dst = ip->ip_dst;
         cp = (u_char *)(ip + 1);          cp = (u_char *)(ip + 1);
         cnt = (ip->ip_hl << 2) - sizeof (struct ip);          cnt = (ip->ip_hl << 2) - sizeof (struct ip);
         for (; cnt > 0; cnt -= optlen, cp += optlen) {          for (; cnt > 0; cnt -= optlen, cp += optlen) {
Line 652  ip_dooptions(m)
Line 712  ip_dooptions(m)
 #define INA     struct in_ifaddr *  #define INA     struct in_ifaddr *
 #define SA      struct sockaddr *  #define SA      struct sockaddr *
                             if ((ia = (INA)ifa_ifwithdstaddr((SA)&ipaddr)) == 0)                              if ((ia = (INA)ifa_ifwithdstaddr((SA)&ipaddr)) == 0)
                                 ia = in_iaonnetof(in_netof(ipaddr.sin_addr));                                  ia = (INA)ifa_ifwithnet((SA)&ipaddr);
                         } else                          } else
                                 ia = ip_rtaddr(ipaddr.sin_addr);                                  ia = ip_rtaddr(ipaddr.sin_addr);
                         if (ia == 0) {                          if (ia == 0) {
Line 664  ip_dooptions(m)
Line 724  ip_dooptions(m)
                         bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),                          bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
                             (caddr_t)(cp + off), sizeof(struct in_addr));                              (caddr_t)(cp + off), sizeof(struct in_addr));
                         cp[IPOPT_OFFSET] += sizeof(struct in_addr);                          cp[IPOPT_OFFSET] += sizeof(struct in_addr);
                         forward = 1;                          /*
                            * Let ip_intr's mcast routing check handle mcast pkts
                            */
                           forward = !IN_MULTICAST(ntohl(ip->ip_dst.s_addr));
                         break;                          break;
   
                 case IPOPT_RR:                  case IPOPT_RR:
Line 715  ip_dooptions(m)
Line 778  ip_dooptions(m)
                                 if (ipt->ipt_ptr + sizeof(n_time) +                                  if (ipt->ipt_ptr + sizeof(n_time) +
                                     sizeof(struct in_addr) > ipt->ipt_len)                                      sizeof(struct in_addr) > ipt->ipt_len)
                                         goto bad;                                          goto bad;
                                 ia = ifptoia(m->m_pkthdr.rcvif);                                  ipaddr.sin_addr = dst;
                                   ia = (INA)ifaof_ifpforaddr((SA)&ipaddr,
                                                               m->m_pkthdr.rcvif);
                                   if (ia == 0)
                                           continue;
                                 bcopy((caddr_t)&IA_SIN(ia)->sin_addr,                                  bcopy((caddr_t)&IA_SIN(ia)->sin_addr,
                                     (caddr_t)sin, sizeof(struct in_addr));                                      (caddr_t)sin, sizeof(struct in_addr));
                                 ipt->ipt_ptr += sizeof(struct in_addr);                                  ipt->ipt_ptr += sizeof(struct in_addr);
Line 744  ip_dooptions(m)
Line 811  ip_dooptions(m)
         if (forward) {          if (forward) {
                 ip_forward(m, 1);                  ip_forward(m, 1);
                 return (1);                  return (1);
         } else          }
                 return (0);          return (0);
 bad:  bad:
         icmp_error(m, type, code);          ip->ip_len -= ip->ip_hl << 2;   /* XXX icmp_error adds in hdr length */
           icmp_error(m, type, code, 0, 0);
           ipstat.ips_badoptions++;
         return (1);          return (1);
 }  }
   
Line 783  ip_rtaddr(dst)
Line 852  ip_rtaddr(dst)
  * Save incoming source route for use in replies,   * Save incoming source route for use in replies,
  * to be picked up later by ip_srcroute if the receiver is interested.   * to be picked up later by ip_srcroute if the receiver is interested.
  */   */
   void
 save_rte(option, dst)  save_rte(option, dst)
         u_char *option;          u_char *option;
         struct in_addr dst;          struct in_addr dst;
Line 877  ip_srcroute()
Line 947  ip_srcroute()
  * will be moved, and return value is their length.   * will be moved, and return value is their length.
  * XXX should be deleted; last arg currently ignored.   * XXX should be deleted; last arg currently ignored.
  */   */
   void
 ip_stripoptions(m, mopt)  ip_stripoptions(m, mopt)
         register struct mbuf *m;          register struct mbuf *m;
         struct mbuf *mopt;          struct mbuf *mopt;
Line 919  u_char inetctlerrmap[PRC_NCMDS] = {
Line 990  u_char inetctlerrmap[PRC_NCMDS] = {
  * The srcrt parameter indicates whether the packet is being forwarded   * The srcrt parameter indicates whether the packet is being forwarded
  * via a source route.   * via a source route.
  */   */
   void
 ip_forward(m, srcrt)  ip_forward(m, srcrt)
         struct mbuf *m;          struct mbuf *m;
         int srcrt;          int srcrt;
Line 928  ip_forward(m, srcrt)
Line 1000  ip_forward(m, srcrt)
         register struct rtentry *rt;          register struct rtentry *rt;
         int error, type = 0, code;          int error, type = 0, code;
         struct mbuf *mcopy;          struct mbuf *mcopy;
         struct in_addr dest;          n_long dest;
           struct ifnet *destifp;
   
         dest.s_addr = 0;          dest = 0;
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (ipprintfs)          if (ipprintfs)
                 printf("forward: src %x dst %x ttl %x\n", ip->ip_src,                  printf("forward: src %x dst %x ttl %x\n", ip->ip_src,
Line 943  ip_forward(m, srcrt)
Line 1016  ip_forward(m, srcrt)
         }          }
         HTONS(ip->ip_id);          HTONS(ip->ip_id);
         if (ip->ip_ttl <= IPTTLDEC) {          if (ip->ip_ttl <= IPTTLDEC) {
                 icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest);                  icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
                 return;                  return;
         }          }
         ip->ip_ttl -= IPTTLDEC;          ip->ip_ttl -= IPTTLDEC;
Line 961  ip_forward(m, srcrt)
Line 1034  ip_forward(m, srcrt)
   
                 rtalloc(&ipforward_rt);                  rtalloc(&ipforward_rt);
                 if (ipforward_rt.ro_rt == 0) {                  if (ipforward_rt.ro_rt == 0) {
                         icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, dest);                          icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, dest, 0);
                         return;                          return;
                 }                  }
                 rt = ipforward_rt.ro_rt;                  rt = ipforward_rt.ro_rt;
Line 990  ip_forward(m, srcrt)
Line 1063  ip_forward(m, srcrt)
             (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&              (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
             satosin(rt_key(rt))->sin_addr.s_addr != 0 &&              satosin(rt_key(rt))->sin_addr.s_addr != 0 &&
             ipsendredirects && !srcrt) {              ipsendredirects && !srcrt) {
                 struct in_ifaddr *ia;  #define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))
                 u_long src = ntohl(ip->ip_src.s_addr);                  u_long src = ntohl(ip->ip_src.s_addr);
                 u_long dst = ntohl(ip->ip_dst.s_addr);  
   
                 if ((ia = ifptoia(m->m_pkthdr.rcvif)) &&                  if (RTA(rt) &&
                    (src & ia->ia_subnetmask) == ia->ia_subnet) {                      (src & RTA(rt)->ia_subnetmask) == RTA(rt)->ia_subnet) {
                     if (rt->rt_flags & RTF_GATEWAY)                      if (rt->rt_flags & RTF_GATEWAY)
                         dest = satosin(rt->rt_gateway)->sin_addr;                          dest = satosin(rt->rt_gateway)->sin_addr.s_addr;
                     else                      else
                         dest = ip->ip_dst;                          dest = ip->ip_dst.s_addr;
                     /*                      /* Router requirements says to only send host redirects */
                      * If the destination is reached by a route to host,  
                      * is on a subnet of a local net, or is directly  
                      * on the attached net (!), use host redirect.  
                      * (We may be the correct first hop for other subnets.)  
                      */  
 #define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))  
                     type = ICMP_REDIRECT;                      type = ICMP_REDIRECT;
                     if ((rt->rt_flags & RTF_HOST) ||                      code = ICMP_REDIRECT_HOST;
                         (rt->rt_flags & RTF_GATEWAY) == 0)  
                             code = ICMP_REDIRECT_HOST;  
                     else if (RTA(rt)->ia_subnetmask != RTA(rt)->ia_netmask &&  
                         (dst & RTA(rt)->ia_netmask) ==  RTA(rt)->ia_net)  
                             code = ICMP_REDIRECT_HOST;  
                     else  
                             code = ICMP_REDIRECT_NET;  
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
                     if (ipprintfs)                      if (ipprintfs)
                         printf("redirect (%d) to %x\n", code, dest.s_addr);                          printf("redirect (%d) to %lx\n", code, (u_long)dest);
 #endif  #endif
                 }                  }
         }          }
   
         error = ip_output(m, (struct mbuf *)0, &ipforward_rt, IP_FORWARDING);          error = ip_output(m, (struct mbuf *)0, &ipforward_rt, IP_FORWARDING
   #ifdef DIRECTED_BROADCAST
                               | IP_ALLOWBROADCAST
   #endif
                                                   , 0);
         if (error)          if (error)
                 ipstat.ips_cantforward++;                  ipstat.ips_cantforward++;
         else {          else {
Line 1038  ip_forward(m, srcrt)
Line 1101  ip_forward(m, srcrt)
         }          }
         if (mcopy == NULL)          if (mcopy == NULL)
                 return;                  return;
           destifp = NULL;
   
         switch (error) {          switch (error) {
   
         case 0:                         /* forwarded, but need redirect */          case 0:                         /* forwarded, but need redirect */
Line 1056  ip_forward(m, srcrt)
Line 1121  ip_forward(m, srcrt)
         case EMSGSIZE:          case EMSGSIZE:
                 type = ICMP_UNREACH;                  type = ICMP_UNREACH;
                 code = ICMP_UNREACH_NEEDFRAG;                  code = ICMP_UNREACH_NEEDFRAG;
                   if (ipforward_rt.ro_rt)
                           destifp = ipforward_rt.ro_rt->rt_ifp;
                 ipstat.ips_cantfrag++;                  ipstat.ips_cantfrag++;
                 break;                  break;
   
Line 1064  ip_forward(m, srcrt)
Line 1131  ip_forward(m, srcrt)
                 code = 0;                  code = 0;
                 break;                  break;
         }          }
         icmp_error(mcopy, type, code, dest);          icmp_error(mcopy, type, code, dest, destifp);
   }
   
   int
   ip_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
           int *name;
           u_int namelen;
           void *oldp;
           size_t *oldlenp;
           void *newp;
           size_t newlen;
   {
           /* All sysctl names at this level are terminal. */
           if (namelen != 1)
                   return (ENOTDIR);
   
           switch (name[0]) {
           case IPCTL_FORWARDING:
                   return (sysctl_int(oldp, oldlenp, newp, newlen, &ipforwarding));
           case IPCTL_SENDREDIRECTS:
                   return (sysctl_int(oldp, oldlenp, newp, newlen,
                           &ipsendredirects));
           case IPCTL_DEFTTL:
                   return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_defttl));
   #ifdef notyet
           case IPCTL_DEFMTU:
                   return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_mtu));
   #endif
           default:
                   return (EOPNOTSUPP);
           }
           /* NOTREACHED */
 }  }

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2

CVSweb <webmaster@jp.NetBSD.org>