[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.66 and 1.82.2.4

version 1.66, 1998/05/24 20:14:53 version 1.82.2.4, 2000/02/12 18:10:24
Line 73 
Line 73 
  */   */
   
 #include "opt_gateway.h"  #include "opt_gateway.h"
   #include "opt_pfil_hooks.h"
 #include "opt_mrouting.h"  #include "opt_mrouting.h"
   
 #include <sys/param.h>  #include <sys/param.h>
Line 87 
Line 88 
 #include <sys/time.h>  #include <sys/time.h>
 #include <sys/kernel.h>  #include <sys/kernel.h>
 #include <sys/proc.h>  #include <sys/proc.h>
   #include <sys/pool.h>
   
 #include <vm/vm.h>  #include <vm/vm.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
Line 162  struct ifqueue ipintrq;
Line 164  struct ifqueue ipintrq;
 struct  ipstat  ipstat;  struct  ipstat  ipstat;
 u_int16_t       ip_id;  u_int16_t       ip_id;
 int     ip_defttl;  int     ip_defttl;
   
 struct ipqhead ipq;  struct ipqhead ipq;
   int     ipq_locked;
   
   static __inline int ipq_lock_try __P((void));
   static __inline void ipq_unlock __P((void));
   
   static __inline int
   ipq_lock_try()
   {
           int s;
   
           s = splimp();
           if (ipq_locked) {
                   splx(s);
                   return (0);
           }
           ipq_locked = 1;
           splx(s);
           return (1);
   }
   
   static __inline void
   ipq_unlock()
   {
           int s;
   
           s = splimp();
           ipq_locked = 0;
           splx(s);
   }
   
   #ifdef DIAGNOSTIC
   #define IPQ_LOCK()                                                      \
   do {                                                                    \
           if (ipq_lock_try() == 0) {                                      \
                   printf("%s:%d: ipq already locked\n", __FILE__, __LINE__); \
                   panic("ipq_lock");                                      \
           }                                                               \
   } while (0)
   #define IPQ_LOCK_CHECK()                                                \
   do {                                                                    \
           if (ipq_locked == 0) {                                          \
                   printf("%s:%d: ipq lock not held\n", __FILE__, __LINE__); \
                   panic("ipq lock check");                                \
           }                                                               \
   } while (0)
   #else
   #define IPQ_LOCK()              (void) ipq_lock_try()
   #define IPQ_LOCK_CHECK()        /* nothing */
   #endif
   
   #define IPQ_UNLOCK()            ipq_unlock()
   
   struct pool ipqent_pool;
   
 /*  /*
  * 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 191  ip_init()
Line 247  ip_init()
         register struct protosw *pr;          register struct protosw *pr;
         register int i;          register int i;
   
           pool_init(&ipqent_pool, sizeof(struct ipqent), 0, 0, 0, "ipqepl",
               0, NULL, NULL, M_IPQ);
   
         pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);          pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
         if (pr == 0)          if (pr == 0)
                 panic("ip_init");                  panic("ip_init");
Line 210  ip_init()
Line 269  ip_init()
         if (ip_mtudisc != 0)          if (ip_mtudisc != 0)
                 ip_mtudisc_timeout_q =                  ip_mtudisc_timeout_q =
                     rt_timer_queue_create(ip_mtudisc_timeout);                      rt_timer_queue_create(ip_mtudisc_timeout);
   #ifdef GATEWAY
           ipflow_init();
   #endif
 }  }
   
 struct  sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };  struct  sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };
Line 278  next:
Line 340  next:
                 }                  }
                 ip = mtod(m, struct ip *);                  ip = mtod(m, struct ip *);
         }          }
         if ((ip->ip_sum = in_cksum(m, hlen)) != 0) {  
           /*
            * RFC1122: packets with a multicast source address are
            * not allowed.
            */
           if (IN_MULTICAST(ip->ip_src.s_addr)) {
                   /* XXX stat */
                   goto bad;
           }
   
           if (in_cksum(m, hlen) != 0) {
                 ipstat.ips_badsum++;                  ipstat.ips_badsum++;
                 goto bad;                  goto bad;
         }          }
Line 287  next:
Line 359  next:
          * Convert fields to host representation.           * Convert fields to host representation.
          */           */
         NTOHS(ip->ip_len);          NTOHS(ip->ip_len);
         NTOHS(ip->ip_id);  
         NTOHS(ip->ip_off);          NTOHS(ip->ip_off);
         len = ip->ip_len;          len = ip->ip_len;
   
         /*          /*
            * Check for additional length bogosity
            */
           if (len < hlen)
           {
                   ipstat.ips_badlen++;
                   goto bad;
           }
   
           /*
          * Check that the amount of data in the buffers           * Check that the amount of data in the buffers
          * is as at least much as the IP header would have us expect.           * is as at least much as the IP header would have us expect.
          * Trim mbufs if longer than we expect.           * Trim mbufs if longer than we expect.
Line 329  next:
Line 409  next:
                         rv = pfh->pfil_func(ip, hlen, m->m_pkthdr.rcvif, 0, &m0);                          rv = pfh->pfil_func(ip, hlen, m->m_pkthdr.rcvif, 0, &m0);
                         if (rv)                          if (rv)
                                 goto next;                                  goto next;
                         ip = mtod(m = m0, struct ip *);                          m = m0;
                           if (m == NULL)
                                   goto next;
                           ip = mtod(m, struct ip *);
                 }                  }
 #endif /* PFIL_HOOKS */  #endif /* PFIL_HOOKS */
   
Line 347  next:
Line 430  next:
          * Check our list of addresses, to see if the packet is for us.           * Check our list of addresses, to see if the packet is for us.
          */           */
         INADDR_TO_IA(ip->ip_dst, ia);          INADDR_TO_IA(ip->ip_dst, ia);
         if (ia != NULL) goto ours;          if (ia != NULL)
                   goto ours;
         if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {          if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {
                 for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first;                  for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first;
                     ifa != NULL; ifa = ifa->ifa_list.tqe_next) {                      ifa != NULL; ifa = ifa->ifa_list.tqe_next) {
Line 396  next:
Line 480  next:
                          * as expected when ip_mforward() is called from                           * as expected when ip_mforward() is called from
                          * ip_output().)                           * ip_output().)
                          */                           */
                         ip->ip_id = htons(ip->ip_id);  
                         if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {                          if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {
                                 ipstat.ips_cantforward++;                                  ipstat.ips_cantforward++;
                                 m_freem(m);                                  m_freem(m);
                                 goto next;                                  goto next;
                         }                          }
                         ip->ip_id = ntohs(ip->ip_id);  
   
                         /*                          /*
                          * The process-level routing demon needs to receive                           * The process-level routing demon needs to receive
Line 453  ours:
Line 535  ours:
                  * Look for queue of fragments                   * Look for queue of fragments
                  * of this datagram.                   * of this datagram.
                  */                   */
                   IPQ_LOCK();
                 for (fp = ipq.lh_first; fp != NULL; fp = fp->ipq_q.le_next)                  for (fp = ipq.lh_first; fp != NULL; fp = fp->ipq_q.le_next)
                         if (ip->ip_id == fp->ipq_id &&                          if (ip->ip_id == fp->ipq_id &&
                             in_hosteq(ip->ip_src, fp->ipq_src) &&                              in_hosteq(ip->ip_src, fp->ipq_src) &&
Line 476  found:
Line 559  found:
                          */                           */
                         if (ip->ip_len == 0 || (ip->ip_len & 0x7) != 0) {                          if (ip->ip_len == 0 || (ip->ip_len & 0x7) != 0) {
                                 ipstat.ips_badfrags++;                                  ipstat.ips_badfrags++;
                                   IPQ_UNLOCK();
                                 goto bad;                                  goto bad;
                         }                          }
                 }                  }
Line 488  found:
Line 572  found:
                  */                   */
                 if (mff || ip->ip_off) {                  if (mff || ip->ip_off) {
                         ipstat.ips_fragments++;                          ipstat.ips_fragments++;
                         MALLOC(ipqe, struct ipqent *, sizeof (struct ipqent),                          ipqe = pool_get(&ipqent_pool, PR_NOWAIT);
                             M_IPQ, M_NOWAIT);  
                         if (ipqe == NULL) {                          if (ipqe == NULL) {
                                 ipstat.ips_rcvmemdrop++;                                  ipstat.ips_rcvmemdrop++;
                                   IPQ_UNLOCK();
                                 goto bad;                                  goto bad;
                         }                          }
                         ipqe->ipqe_mff = mff;                          ipqe->ipqe_mff = mff;
                         ipqe->ipqe_m = m;                          ipqe->ipqe_m = m;
                         ipqe->ipqe_ip = ip;                          ipqe->ipqe_ip = ip;
                         m = ip_reass(ipqe, fp);                          m = ip_reass(ipqe, fp);
                         if (m == 0)                          if (m == 0) {
                                   IPQ_UNLOCK();
                                 goto next;                                  goto next;
                           }
                         ipstat.ips_reassembled++;                          ipstat.ips_reassembled++;
                         ip = mtod(m, struct ip *);                          ip = mtod(m, struct ip *);
                           hlen = ip->ip_hl << 2;
                           ip->ip_len += hlen;
                 } else                  } else
                         if (fp)                          if (fp)
                                 ip_freef(fp);                                  ip_freef(fp);
         } else                  IPQ_UNLOCK();
                 ip->ip_len -= hlen;          }
   
         /*          /*
          * Switch out to protocol's input routine.           * Switch out to protocol's input routine.
          */           */
   #if IFA_STATS
           ia->ia_ifa.ifa_data.ifad_inbytes += ip->ip_len;
   #endif
         ipstat.ips_delivered++;          ipstat.ips_delivered++;
         (*inetsw[ip_protox[ip->ip_p]].pr_input)(m, hlen);          (*inetsw[ip_protox[ip->ip_p]].pr_input)(m, hlen);
         goto next;          goto next;
Line 537  ip_reass(ipqe, fp)
Line 628  ip_reass(ipqe, fp)
         int hlen = ipqe->ipqe_ip->ip_hl << 2;          int hlen = ipqe->ipqe_ip->ip_hl << 2;
         int i, next;          int i, next;
   
           IPQ_LOCK_CHECK();
   
         /*          /*
          * Presence of header sizes in mbufs           * Presence of header sizes in mbufs
          * would confuse code below.           * would confuse code below.
Line 605  ip_reass(ipqe, fp)
Line 698  ip_reass(ipqe, fp)
                 nq = q->ipqe_q.le_next;                  nq = q->ipqe_q.le_next;
                 m_freem(q->ipqe_m);                  m_freem(q->ipqe_m);
                 LIST_REMOVE(q, ipqe_q);                  LIST_REMOVE(q, ipqe_q);
                 FREE(q, M_IPQ);                  pool_put(&ipqent_pool, q);
         }          }
   
 insert:  insert:
Line 644  insert:
Line 737  insert:
         m->m_next = 0;          m->m_next = 0;
         m_cat(m, t);          m_cat(m, t);
         nq = q->ipqe_q.le_next;          nq = q->ipqe_q.le_next;
         FREE(q, M_IPQ);          pool_put(&ipqent_pool, q);
         for (q = nq; q != NULL; q = nq) {          for (q = nq; q != NULL; q = nq) {
                 t = q->ipqe_m;                  t = q->ipqe_m;
                 nq = q->ipqe_q.le_next;                  nq = q->ipqe_q.le_next;
                 FREE(q, M_IPQ);                  pool_put(&ipqent_pool, q);
                 m_cat(m, t);                  m_cat(m, t);
         }          }
   
Line 677  insert:
Line 770  insert:
 dropfrag:  dropfrag:
         ipstat.ips_fragdropped++;          ipstat.ips_fragdropped++;
         m_freem(m);          m_freem(m);
         FREE(ipqe, M_IPQ);          pool_put(&ipqent_pool, ipqe);
         return (0);          return (0);
 }  }
   
Line 691  ip_freef(fp)
Line 784  ip_freef(fp)
 {  {
         register struct ipqent *q, *p;          register struct ipqent *q, *p;
   
           IPQ_LOCK_CHECK();
   
         for (q = fp->ipq_fragq.lh_first; q != NULL; q = p) {          for (q = fp->ipq_fragq.lh_first; q != NULL; q = p) {
                 p = q->ipqe_q.le_next;                  p = q->ipqe_q.le_next;
                 m_freem(q->ipqe_m);                  m_freem(q->ipqe_m);
                 LIST_REMOVE(q, ipqe_q);                  LIST_REMOVE(q, ipqe_q);
                 FREE(q, M_IPQ);                  pool_put(&ipqent_pool, q);
         }          }
         LIST_REMOVE(fp, ipq_q);          LIST_REMOVE(fp, ipq_q);
         FREE(fp, M_FTABLE);          FREE(fp, M_FTABLE);
Line 712  ip_slowtimo()
Line 807  ip_slowtimo()
         register struct ipq *fp, *nfp;          register struct ipq *fp, *nfp;
         int s = splsoftnet();          int s = splsoftnet();
   
           IPQ_LOCK();
         for (fp = ipq.lh_first; fp != NULL; fp = nfp) {          for (fp = ipq.lh_first; fp != NULL; fp = nfp) {
                 nfp = fp->ipq_q.le_next;                  nfp = fp->ipq_q.le_next;
                 if (--fp->ipq_ttl == 0) {                  if (--fp->ipq_ttl == 0) {
Line 719  ip_slowtimo()
Line 815  ip_slowtimo()
                         ip_freef(fp);                          ip_freef(fp);
                 }                  }
         }          }
           IPQ_UNLOCK();
 #ifdef GATEWAY  #ifdef GATEWAY
         ipflow_slowtimo();          ipflow_slowtimo();
 #endif  #endif
Line 732  void
Line 829  void
 ip_drain()  ip_drain()
 {  {
   
           /*
            * We may be called from a device's interrupt context.  If
            * the ipq is already busy, just bail out now.
            */
           if (ipq_lock_try() == 0)
                   return;
   
         while (ipq.lh_first != NULL) {          while (ipq.lh_first != NULL) {
                 ipstat.ips_fragdropped++;                  ipstat.ips_fragdropped++;
                 ip_freef(ipq.lh_first);                  ip_freef(ipq.lh_first);
         }          }
   
           IPQ_UNLOCK();
 }  }
   
 /*  /*
Line 935  ip_dooptions(m)
Line 1041  ip_dooptions(m)
         }          }
         return (0);          return (0);
 bad:  bad:
         ip->ip_len -= ip->ip_hl << 2;   /* XXX icmp_error adds in hdr length */  
         icmp_error(m, type, code, 0, 0);          icmp_error(m, type, code, 0, 0);
         ipstat.ips_badoptions++;          ipstat.ips_badoptions++;
         return (1);          return (1);
Line 1078  ip_stripoptions(m, mopt)
Line 1183  ip_stripoptions(m, mopt)
         register caddr_t opts;          register caddr_t opts;
         int olen;          int olen;
   
         olen = (ip->ip_hl<<2) - sizeof (struct ip);          olen = (ip->ip_hl << 2) - sizeof (struct ip);
         opts = (caddr_t)(ip + 1);          opts = (caddr_t)(ip + 1);
         i = m->m_len - (sizeof (struct ip) + olen);          i = m->m_len - (sizeof (struct ip) + olen);
         bcopy(opts  + olen, opts, (unsigned)i);          bcopy(opts  + olen, opts, (unsigned)i);
         m->m_len -= olen;          m->m_len -= olen;
         if (m->m_flags & M_PKTHDR)          if (m->m_flags & M_PKTHDR)
                 m->m_pkthdr.len -= olen;                  m->m_pkthdr.len -= olen;
         ip->ip_hl = sizeof(struct ip) >> 2;          ip->ip_len -= olen;
           ip->ip_hl = sizeof (struct ip) >> 2;
 }  }
   
 int inetctlerrmap[PRC_NCMDS] = {  int inetctlerrmap[PRC_NCMDS] = {
Line 1127  ip_forward(m, srcrt)
Line 1233  ip_forward(m, srcrt)
         dest = 0;          dest = 0;
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (ipprintfs)          if (ipprintfs)
                 printf("forward: src %x dst %x ttl %x\n",                  printf("forward: src %2.2x dst %2.2x ttl %x\n",
                     ip->ip_src.s_addr, ip->ip_dst.s_addr, ip->ip_ttl);                      ntohl(ip->ip_src.s_addr),
                       ntohl(ip->ip_dst.s_addr), ip->ip_ttl);
 #endif  #endif
         if (m->m_flags & M_BCAST || in_canforward(ip->ip_dst) == 0) {          if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
                 ipstat.ips_cantforward++;                  ipstat.ips_cantforward++;
                 m_freem(m);                  m_freem(m);
                 return;                  return;
         }          }
         HTONS(ip->ip_id);  
         if (ip->ip_ttl <= IPTTLDEC) {          if (ip->ip_ttl <= IPTTLDEC) {
                 icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);                  icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
                 return;                  return;
Line 1182  ip_forward(m, srcrt)
Line 1288  ip_forward(m, srcrt)
                 if (rt->rt_ifa &&                  if (rt->rt_ifa &&
                     (ip->ip_src.s_addr & ifatoia(rt->rt_ifa)->ia_subnetmask) ==                      (ip->ip_src.s_addr & ifatoia(rt->rt_ifa)->ia_subnetmask) ==
                     ifatoia(rt->rt_ifa)->ia_subnet) {                      ifatoia(rt->rt_ifa)->ia_subnet) {
                     if (rt->rt_flags & RTF_GATEWAY)                          if (rt->rt_flags & RTF_GATEWAY)
                         dest = satosin(rt->rt_gateway)->sin_addr.s_addr;                                  dest = satosin(rt->rt_gateway)->sin_addr.s_addr;
                     else                          else
                         dest = ip->ip_dst.s_addr;                                  dest = ip->ip_dst.s_addr;
                     /* Router requirements says to only send host redirects */                          /*
                     type = ICMP_REDIRECT;                           * Router requirements says to only send host
                     code = ICMP_REDIRECT_HOST;                           * redirects.
                            */
                           type = ICMP_REDIRECT;
                           code = ICMP_REDIRECT_HOST;
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
                     if (ipprintfs)                          if (ipprintfs)
                         printf("redirect (%d) to %x\n", code, (u_int32_t)dest);                                  printf("redirect (%d) to %x\n", code,
                                       (u_int32_t)dest);
 #endif  #endif
                 }                  }
         }          }
Line 1400  ip_sysctl(name, namelen, oldp, oldlenp, 
Line 1510  ip_sysctl(name, namelen, oldp, oldlenp, 
                 return (error);                  return (error);
 #ifdef GATEWAY  #ifdef GATEWAY
         case IPCTL_MAXFLOWS:          case IPCTL_MAXFLOWS:
               {
                   int s;
   
                 error = sysctl_int(oldp, oldlenp, newp, newlen,                  error = sysctl_int(oldp, oldlenp, newp, newlen,
                    &ip_maxflows);                     &ip_maxflows);
                   s = splsoftnet();
                 ipflow_reap(0);                  ipflow_reap(0);
                   splx(s);
                 return (error);                  return (error);
               }
 #endif  #endif
         default:          default:
                 return (EOPNOTSUPP);                  return (EOPNOTSUPP);

Legend:
Removed from v.1.66  
changed lines
  Added in v.1.82.2.4

CVSweb <webmaster@jp.NetBSD.org>