[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.263 and 1.264

version 1.263, 2008/03/27 00:18:56 version 1.264, 2008/04/07 06:31:28
Line 230  u_long in_multihash;    /* size of hash 
Line 230  u_long in_multihash;    /* size of hash 
 int     in_multientries;                        /* total number of addrs */  int     in_multientries;                        /* total number of addrs */
 struct  in_multihashhead *in_multihashtbl;  struct  in_multihashhead *in_multihashtbl;
 struct  ifqueue ipintrq;  struct  ifqueue ipintrq;
 struct  ipstat  ipstat;  uint64_t ipstat[IP_NSTATS];
 uint16_t ip_id;  uint16_t ip_id;
   
 #ifdef PFIL_HOOKS  #ifdef PFIL_HOOKS
Line 511  ip_input(struct mbuf *m)
Line 511  ip_input(struct mbuf *m)
          */           */
         if (TAILQ_FIRST(&in_ifaddrhead) == 0)          if (TAILQ_FIRST(&in_ifaddrhead) == 0)
                 goto bad;                  goto bad;
         ipstat.ips_total++;          ipstat[IP_STAT_TOTAL]++;
         /*          /*
          * If the IP header is not aligned, slurp it up into a new           * If the IP header is not aligned, slurp it up into a new
          * mbuf with space for link headers, in the event we forward           * mbuf with space for link headers, in the event we forward
Line 522  ip_input(struct mbuf *m)
Line 522  ip_input(struct mbuf *m)
                 if ((m = m_copyup(m, sizeof(struct ip),                  if ((m = m_copyup(m, sizeof(struct ip),
                                   (max_linkhdr + 3) & ~3)) == NULL) {                                    (max_linkhdr + 3) & ~3)) == NULL) {
                         /* XXXJRT new stat, please */                          /* XXXJRT new stat, please */
                         ipstat.ips_toosmall++;                          ipstat[IP_STAT_TOOSMALL]++;
                         return;                          return;
                 }                  }
         } else if (__predict_false(m->m_len < sizeof (struct ip))) {          } else if (__predict_false(m->m_len < sizeof (struct ip))) {
                 if ((m = m_pullup(m, sizeof (struct ip))) == NULL) {                  if ((m = m_pullup(m, sizeof (struct ip))) == NULL) {
                         ipstat.ips_toosmall++;                          ipstat[IP_STAT_TOOSMALL]++;
                         return;                          return;
                 }                  }
         }          }
         ip = mtod(m, struct ip *);          ip = mtod(m, struct ip *);
         if (ip->ip_v != IPVERSION) {          if (ip->ip_v != IPVERSION) {
                 ipstat.ips_badvers++;                  ipstat[IP_STAT_BADVERS]++;
                 goto bad;                  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[IP_STAT_BADHLEN]++;
                 goto bad;                  goto bad;
         }          }
         if (hlen > m->m_len) {          if (hlen > m->m_len) {
                 if ((m = m_pullup(m, hlen)) == 0) {                  if ((m = m_pullup(m, hlen)) == 0) {
                         ipstat.ips_badhlen++;                          ipstat[IP_STAT_BADHLEN]++;
                         return;                          return;
                 }                  }
                 ip = mtod(m, struct ip *);                  ip = mtod(m, struct ip *);
Line 554  ip_input(struct mbuf *m)
Line 554  ip_input(struct mbuf *m)
          * not allowed.           * not allowed.
          */           */
         if (IN_MULTICAST(ip->ip_src.s_addr)) {          if (IN_MULTICAST(ip->ip_src.s_addr)) {
                 ipstat.ips_badaddr++;                  ipstat[IP_STAT_BADADDR]++;
                 goto bad;                  goto bad;
         }          }
   
Line 562  ip_input(struct mbuf *m)
Line 562  ip_input(struct mbuf *m)
         if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||          if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
             (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {              (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
                 if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {                  if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {
                         ipstat.ips_badaddr++;                          ipstat[IP_STAT_BADADDR]++;
                         goto bad;                          goto bad;
                 }                  }
         }          }
Line 600  ip_input(struct mbuf *m)
Line 600  ip_input(struct mbuf *m)
          * Check for additional length bogosity           * Check for additional length bogosity
          */           */
         if (len < hlen) {          if (len < hlen) {
                 ipstat.ips_badlen++;                  ipstat[IP_STAT_BADLEN]++;
                 goto bad;                  goto bad;
         }          }
   
Line 611  ip_input(struct mbuf *m)
Line 611  ip_input(struct mbuf *m)
          * Drop packet if shorter than we expect.           * Drop packet if shorter than we expect.
          */           */
         if (m->m_pkthdr.len < len) {          if (m->m_pkthdr.len < len) {
                 ipstat.ips_tooshort++;                  ipstat[IP_STAT_TOOSHORT]++;
                 goto bad;                  goto bad;
         }          }
         if (m->m_pkthdr.len > len) {          if (m->m_pkthdr.len > len) {
Line 780  ip_input(struct mbuf *m)
Line 780  ip_input(struct mbuf *m)
                          * ip_output().)                           * ip_output().)
                          */                           */
                         if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {                          if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {
                                 ipstat.ips_cantforward++;                                  ipstat[IP_STAT_CANTFORWARD]++;
                                 m_freem(m);                                  m_freem(m);
                                 return;                                  return;
                         }                          }
Line 792  ip_input(struct mbuf *m)
Line 792  ip_input(struct mbuf *m)
                          */                           */
                         if (ip->ip_p == IPPROTO_IGMP)                          if (ip->ip_p == IPPROTO_IGMP)
                                 goto ours;                                  goto ours;
                         ipstat.ips_forward++;                          ipstat[IP_STAT_CANTFORWARD]++;
                 }                  }
 #endif  #endif
                 /*                  /*
Line 801  ip_input(struct mbuf *m)
Line 801  ip_input(struct mbuf *m)
                  */                   */
                 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++;                          ipstat[IP_STAT_CANTFORWARD]++;
                         m_freem(m);                          m_freem(m);
                         return;                          return;
                 }                  }
Line 815  ip_input(struct mbuf *m)
Line 815  ip_input(struct mbuf *m)
          * Not for us; forward if possible and desirable.           * Not for us; forward if possible and desirable.
          */           */
         if (ipforwarding == 0) {          if (ipforwarding == 0) {
                 ipstat.ips_cantforward++;                  ipstat[IP_STAT_CANTFORWARD]++;
                 m_freem(m);                  m_freem(m);
         } else {          } else {
                 /*                  /*
Line 826  ip_input(struct mbuf *m)
Line 826  ip_input(struct mbuf *m)
                  */                   */
                 if (downmatch) {                  if (downmatch) {
                         icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);                          icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
                         ipstat.ips_cantforward++;                          ipstat[IP_STAT_CANTFORWARD]++;
                         return;                          return;
                 }                  }
 #ifdef IPSEC  #ifdef IPSEC
Line 859  ip_input(struct mbuf *m)
Line 859  ip_input(struct mbuf *m)
                 KEY_FREESP(&sp);                  KEY_FREESP(&sp);
                 splx(s);                  splx(s);
                 if (error) {                  if (error) {
                         ipstat.ips_cantforward++;                          ipstat[IP_STAT_CANTFORWARD]++;
                         goto bad;                          goto bad;
                 }                  }
   
Line 906  ours:
Line 906  ours:
                  */                   */
                 off = (ntohs(ip->ip_off) & IP_OFFMASK) << 3;                  off = (ntohs(ip->ip_off) & IP_OFFMASK) << 3;
                 if ((off > 0 ? off + hlen : len) < IP_MINFRAGSIZE - 1) {                  if ((off > 0 ? off + hlen : len) < IP_MINFRAGSIZE - 1) {
                         ipstat.ips_badfrags++;                          ipstat[IP_STAT_BADFRAGS]++;
                         goto bad;                          goto bad;
                 }                  }
                 /*                  /*
Line 925  ours:
Line 925  ours:
                                  * fragments.                                   * fragments.
                                  */                                   */
                                 if (ip->ip_tos != fp->ipq_tos) {                                  if (ip->ip_tos != fp->ipq_tos) {
                                         ipstat.ips_badfrags++;                                          ipstat[IP_STAT_BADFRAGS]++;
                                         goto bad;                                          goto bad;
                                 }                                  }
                                 goto found;                                  goto found;
Line 948  found:
Line 948  found:
                          */                           */
                         if (ntohs(ip->ip_len) == 0 ||                          if (ntohs(ip->ip_len) == 0 ||
                             (ntohs(ip->ip_len) & 0x7) != 0) {                              (ntohs(ip->ip_len) & 0x7) != 0) {
                                 ipstat.ips_badfrags++;                                  ipstat[IP_STAT_BADFRAGS]++;
                                 IPQ_UNLOCK();                                  IPQ_UNLOCK();
                                 goto bad;                                  goto bad;
                         }                          }
Line 961  found:
Line 961  found:
                  * attempt reassembly; if it succeeds, proceed.                   * attempt reassembly; if it succeeds, proceed.
                  */                   */
                 if (mff || ip->ip_off != htons(0)) {                  if (mff || ip->ip_off != htons(0)) {
                         ipstat.ips_fragments++;                          ipstat[IP_STAT_FRAGMENTS]++;
                         s = splvm();                          s = splvm();
                         ipqe = pool_get(&ipqent_pool, PR_NOWAIT);                          ipqe = pool_get(&ipqent_pool, PR_NOWAIT);
                         splx(s);                          splx(s);
                         if (ipqe == NULL) {                          if (ipqe == NULL) {
                                 ipstat.ips_rcvmemdrop++;                                  ipstat[IP_STAT_RCVMEMDROP]++;
                                 IPQ_UNLOCK();                                  IPQ_UNLOCK();
                                 goto bad;                                  goto bad;
                         }                          }
Line 978  found:
Line 978  found:
                                 IPQ_UNLOCK();                                  IPQ_UNLOCK();
                                 return;                                  return;
                         }                          }
                         ipstat.ips_reassembled++;                          ipstat[IP_STAT_REASSEMBLED]++;
                         ip = mtod(m, struct ip *);                          ip = mtod(m, struct ip *);
                         hlen = ip->ip_hl << 2;                          hlen = ip->ip_hl << 2;
                         ip->ip_len = htons(ntohs(ip->ip_len) + hlen);                          ip->ip_len = htons(ntohs(ip->ip_len) + hlen);
Line 1046  DPRINTF(("ip_input: no SP, packet discar
Line 1046  DPRINTF(("ip_input: no SP, packet discar
         if (ia && ip)          if (ia && ip)
                 ia->ia_ifa.ifa_data.ifad_inbytes += ntohs(ip->ip_len);                  ia->ia_ifa.ifa_data.ifad_inbytes += ntohs(ip->ip_len);
 #endif  #endif
         ipstat.ips_delivered++;          ipstat[IP_STAT_DELIVERED]++;
     {      {
         int off = hlen, nh = ip->ip_p;          int off = hlen, nh = ip->ip_p;
   
Line 1058  bad:
Line 1058  bad:
         return;          return;
   
 badcsum:  badcsum:
         ipstat.ips_badsum++;          ipstat[IP_STAT_BADSUM]++;
         m_freem(m);          m_freem(m);
 }  }
   
Line 1216  insert:
Line 1216  insert:
         q = TAILQ_FIRST(&fp->ipq_fragq);          q = TAILQ_FIRST(&fp->ipq_fragq);
         ip = q->ipqe_ip;          ip = q->ipqe_ip;
         if ((next + (ip->ip_hl << 2)) > IP_MAXPACKET) {          if ((next + (ip->ip_hl << 2)) > IP_MAXPACKET) {
                 ipstat.ips_toolong++;                  ipstat[IP_STAT_TOOLONG]++;
                 ip_freef(fp);                  ip_freef(fp);
                 return (0);                  return (0);
         }          }
Line 1266  dropfrag:
Line 1266  dropfrag:
         if (fp != 0)          if (fp != 0)
                 fp->ipq_nfrags--;                  fp->ipq_nfrags--;
         ip_nfrags--;          ip_nfrags--;
         ipstat.ips_fragdropped++;          ipstat[IP_STAT_FRAGDROPPED]++;
         m_freem(m);          m_freem(m);
         s = splvm();          s = splvm();
         pool_put(&ipqent_pool, ipqe);          pool_put(&ipqent_pool, ipqe);
Line 1333  ip_reass_ttl_decr(u_int ticks)
Line 1333  ip_reass_ttl_decr(u_int ticks)
                                        0 : fp->ipq_ttl - ticks);                                         0 : fp->ipq_ttl - ticks);
                         nfp = LIST_NEXT(fp, ipq_q);                          nfp = LIST_NEXT(fp, ipq_q);
                         if (fp->ipq_ttl == 0) {                          if (fp->ipq_ttl == 0) {
                                 ipstat.ips_fragtimeout++;                                  ipstat[IP_STAT_FRAGTIMEOUT]++;
                                 ip_freef(fp);                                  ip_freef(fp);
                         } else {                          } else {
                                 nfrags += fp->ipq_nfrags;                                  nfrags += fp->ipq_nfrags;
Line 1680  ip_dooptions(struct mbuf *m)
Line 1680  ip_dooptions(struct mbuf *m)
         return (0);          return (0);
 bad:  bad:
         icmp_error(m, type, code, 0, 0);          icmp_error(m, type, code, 0, 0);
         ipstat.ips_badoptions++;          ipstat[IP_STAT_BADOPTIONS]++;
         return (1);          return (1);
 }  }
   
Line 1853  ip_forward(struct mbuf *m, int srcrt)
Line 1853  ip_forward(struct mbuf *m, int srcrt)
         }          }
 #endif  #endif
         if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {          if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
                 ipstat.ips_cantforward++;                  ipstat[IP_STAT_CANTFORWARD]++;
                 m_freem(m);                  m_freem(m);
                 return;                  return;
         }          }
Line 1917  ip_forward(struct mbuf *m, int srcrt)
Line 1917  ip_forward(struct mbuf *m, int srcrt)
             (struct ip_moptions *)NULL, (struct socket *)NULL);              (struct ip_moptions *)NULL, (struct socket *)NULL);
   
         if (error)          if (error)
                 ipstat.ips_cantforward++;                  ipstat[IP_STAT_CANTFORWARD]++;
         else {          else {
                 ipstat.ips_forward++;                  ipstat[IP_STAT_FORWARD]++;
                 if (type)                  if (type)
                         ipstat.ips_redirectsent++;                          ipstat[IP_STAT_REDIRECTSENT]++;
                 else {                  else {
                         if (mcopy) {                          if (mcopy) {
 #ifdef GATEWAY  #ifdef GATEWAY
Line 2008  ip_forward(struct mbuf *m, int srcrt)
Line 2008  ip_forward(struct mbuf *m, int srcrt)
                         }                          }
 #endif /*defined(IPSEC) || defined(FAST_IPSEC)*/  #endif /*defined(IPSEC) || defined(FAST_IPSEC)*/
                 }                  }
                 ipstat.ips_cantfrag++;                  ipstat[IP_STAT_CANTFRAG]++;
                 break;                  break;
   
         case ENOBUFS:          case ENOBUFS:
Line 2391  SYSCTL_SETUP(sysctl_net_inet_ip_setup, "
Line 2391  SYSCTL_SETUP(sysctl_net_inet_ip_setup, "
                        CTLFLAG_PERMANENT,                         CTLFLAG_PERMANENT,
                        CTLTYPE_STRUCT, "stats",                         CTLTYPE_STRUCT, "stats",
                        SYSCTL_DESCR("IP statistics"),                         SYSCTL_DESCR("IP statistics"),
                        NULL, 0, &ipstat, sizeof(ipstat),                         NULL, 0, ipstat, sizeof(ipstat),
                        CTL_NET, PF_INET, IPPROTO_IP, IPCTL_STATS,                         CTL_NET, PF_INET, IPPROTO_IP, IPCTL_STATS,
                        CTL_EOL);                         CTL_EOL);
 }  }

Legend:
Removed from v.1.263  
changed lines
  Added in v.1.264

CVSweb <webmaster@jp.NetBSD.org>