[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.12 and 1.13

version 1.12, 1994/02/14 21:45:53 version 1.13, 1994/05/13 06:06:21
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.
  *   *
  *      from: @(#)ip_input.c    7.19 (Berkeley) 5/25/91   *      from: @(#)ip_input.c    8.2 (Berkeley) 1/4/94
  *      $Id$   *      $Id$
  */   */
   
Line 55 
Line 55 
 #include <netinet/in_var.h>  #include <netinet/in_var.h>
 #include <netinet/ip_var.h>  #include <netinet/ip_var.h>
 #include <netinet/ip_icmp.h>  #include <netinet/ip_icmp.h>
 #include <netinet/ip_mroute.h>  
   
 #ifndef IPFORWARDING  #ifndef IPFORWARDING
 #ifdef GATEWAY  #ifdef GATEWAY
Line 69 
Line 68 
 #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 78  extern struct protosw inetsw[];
Line 78  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 99  extern int if_index;
Line 100  extern int if_index;
 u_long  *ip_ifmatrix;  u_long  *ip_ifmatrix;
 #endif  #endif
   
 static void     ip_forward __P((struct mbuf *, int));  static void save_rte __P((u_char *, struct in_addr));
 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.
Line 127  ip_init()
Line 126  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 148  ipintr()
Line 146  ipintr()
         register struct ipq *fp;          register struct ipq *fp;
         register struct in_ifaddr *ia;          register struct in_ifaddr *ia;
         int hlen, s;          int hlen, s;
 #ifdef DIAGNOSTIC  
         static int busy = 0;  
   
         if (busy)  
                 panic("ipintr: called recursively\n");  
         ++busy;  
 #endif  
 next:  next:
         /*          /*
          * Get next datagram off input queue and get IP header           * Get next datagram off input queue and get IP header
Line 163  next:
Line 155  next:
         s = splimp();          s = splimp();
         IF_DEQUEUE(&ipintrq, m);          IF_DEQUEUE(&ipintrq, m);
         splx(s);          splx(s);
         if (m == 0) {          if (m == 0)
 #ifdef DIAGNOSTIC  
                 --busy;  
 #endif  
                 return;                  return;
         }  
 #ifdef  DIAGNOSTIC  #ifdef  DIAGNOSTIC
         if ((m->m_flags & M_PKTHDR) == 0)          if ((m->m_flags & M_PKTHDR) == 0)
                 panic("ipintr no HDR");                  panic("ipintr no HDR");
Line 186  next:
Line 174  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 300  next:
Line 292  next:
                          * ip_output().)                           * ip_output().)
                          */                           */
                         ip->ip_id = htons(ip->ip_id);                          ip->ip_id = htons(ip->ip_id);
                         if (ip_mforward(ip, m->m_pkthdr.rcvif, m) != 0) {                          if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {
                                   ipstat.ips_cantforward++;
                                 m_freem(m);                                  m_freem(m);
                                 goto next;                                  goto next;
                         }                          }
Line 313  next:
Line 306  next:
                          */                           */
                         if (ip->ip_p == IPPROTO_IGMP)                          if (ip->ip_p == IPPROTO_IGMP)
                                 goto ours;                                  goto ours;
                           ipstat.ips_forward++;
                 }                  }
 #endif  #endif
                 /*                  /*
Line 321  next:
Line 315  next:
                  */                   */
                 IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);                  IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);
                 if (inm == NULL) {                  if (inm == NULL) {
                           ipstat.ips_cantforward++;
                         m_freem(m);                          m_freem(m);
                         goto next;                          goto next;
                 }                  }
Line 376  found:
Line 371  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 386  found:
Line 381  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 505  insert:
Line 499  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 531  insert:
Line 525  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 639  ip_drain()
Line 634  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 658  ip_dooptions(m)
Line 650  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 728  ip_dooptions(m)
Line 721  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 740  ip_dooptions(m)
Line 733  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 791  ip_dooptions(m)
Line 787  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 820  ip_dooptions(m)
Line 820  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:
     {          ip->ip_len -= ip->ip_hl << 2;   /* XXX icmp_error adds in hdr length */
         register struct in_addr foo = {};          icmp_error(m, type, code, 0, 0);
         icmp_error(m, type, code, foo);          ipstat.ips_badoptions++;
     }  
         return (1);          return (1);
 }  }
   
Line 862  ip_rtaddr(dst)
Line 861  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.
  */   */
 static void  void
 save_rte(option, dst)  save_rte(option, dst)
         u_char *option;          u_char *option;
         struct in_addr dst;          struct in_addr dst;
Line 898  ip_srcroute()
Line 897  ip_srcroute()
         if (m == 0)          if (m == 0)
                 return ((struct mbuf *)0);                  return ((struct mbuf *)0);
   
 #define OPTSIZ  (sizeof(ip_srcrt.nop) + sizeof(ip_srcrt.srcopt))  #define OPTSIZ  (sizeof(ip_srcrt.nop) + sizeof(ip_srcrt.srcopt))
   
         /* length is (nhops+1)*sizeof(addr) + sizeof(nop + srcrt header) */          /* length is (nhops+1)*sizeof(addr) + sizeof(nop + srcrt header) */
         m->m_len = ip_nhops * sizeof(struct in_addr) + sizeof(struct in_addr) +          m->m_len = ip_nhops * sizeof(struct in_addr) + sizeof(struct in_addr) +
Line 1000  u_char inetctlerrmap[PRC_NCMDS] = {
Line 999  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.
  */   */
 static void  void
 ip_forward(m, srcrt)  ip_forward(m, srcrt)
         struct mbuf *m;          struct mbuf *m;
         int srcrt;          int srcrt;
Line 1010  ip_forward(m, srcrt)
Line 1009  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 1025  ip_forward(m, srcrt)
Line 1025  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 1043  ip_forward(m, srcrt)
Line 1043  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 1072  ip_forward(m, srcrt)
Line 1072  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, NULL, &ipforward_rt, IP_FORWARDING          error = ip_output(m, (struct mbuf *)0, &ipforward_rt, IP_FORWARDING
 #ifdef DIRECTED_BROADCAST  #ifdef DIRECTED_BROADCAST
             | IP_ALLOWBROADCAST                              | IP_ALLOWBROADCAST
 #endif  #endif
             , NULL);                                                  , 0);
         if (error)          if (error)
                 ipstat.ips_cantforward++;                  ipstat.ips_cantforward++;
         else {          else {
Line 1124  ip_forward(m, srcrt)
Line 1110  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 1142  ip_forward(m, srcrt)
Line 1130  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 1150  ip_forward(m, srcrt)
Line 1140  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.12  
changed lines
  Added in v.1.13

CVSweb <webmaster@jp.NetBSD.org>