[BACK]Return to udp_usrreq.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/udp_usrreq.c between version 1.165 and 1.166

version 1.165, 2008/04/08 23:37:43 version 1.166, 2008/04/12 05:58:22
Line 94  __KERNEL_RCSID(0, "$NetBSD$");
Line 94  __KERNEL_RCSID(0, "$NetBSD$");
 #include <netinet/ip_icmp.h>  #include <netinet/ip_icmp.h>
 #include <netinet/udp.h>  #include <netinet/udp.h>
 #include <netinet/udp_var.h>  #include <netinet/udp_var.h>
   #include <netinet/udp_private.h>
   
 #ifdef INET6  #ifdef INET6
 #include <netinet/ip6.h>  #include <netinet/ip6.h>
Line 144  int udp_do_loopback_cksum = 0;
Line 145  int udp_do_loopback_cksum = 0;
   
 struct  inpcbtable udbtable;  struct  inpcbtable udbtable;
   
 uint64_t        udpstat[UDP_NSTATS];  percpu_t *udpstat_percpu;
   
 #ifdef INET  #ifdef INET
 #ifdef IPSEC_NAT_T  #ifdef IPSEC_NAT_T
Line 231  udp_init(void)
Line 232  udp_init(void)
         MOWNER_ATTACH(&udp_tx_mowner);          MOWNER_ATTACH(&udp_tx_mowner);
         MOWNER_ATTACH(&udp_rx_mowner);          MOWNER_ATTACH(&udp_rx_mowner);
         MOWNER_ATTACH(&udp_mowner);          MOWNER_ATTACH(&udp_mowner);
   
           udpstat_percpu = percpu_alloc(sizeof(uint64_t) * UDP_NSTATS);
 }  }
   
 /*  /*
Line 325  udp4_input_checksum(struct mbuf *m, cons
Line 328  udp4_input_checksum(struct mbuf *m, cons
         return 0;          return 0;
   
 badcsum:  badcsum:
         udpstat[UDP_STAT_BADSUM]++;          UDP_STATINC(UDP_STAT_BADSUM);
         return -1;          return -1;
 }  }
   
Line 347  udp_input(struct mbuf *m, ...)
Line 350  udp_input(struct mbuf *m, ...)
         va_end(ap);          va_end(ap);
   
         MCLAIM(m, &udp_rx_mowner);          MCLAIM(m, &udp_rx_mowner);
         udpstat[UDP_STAT_IPACKETS]++;          UDP_STATINC(UDP_STAT_IPACKETS);
   
         /*          /*
          * Get IP and UDP header together in first mbuf.           * Get IP and UDP header together in first mbuf.
Line 355  udp_input(struct mbuf *m, ...)
Line 358  udp_input(struct mbuf *m, ...)
         ip = mtod(m, struct ip *);          ip = mtod(m, struct ip *);
         IP6_EXTHDR_GET(uh, struct udphdr *, m, iphlen, sizeof(struct udphdr));          IP6_EXTHDR_GET(uh, struct udphdr *, m, iphlen, sizeof(struct udphdr));
         if (uh == NULL) {          if (uh == NULL) {
                 udpstat[UDP_STAT_HDROPS]++;                  UDP_STATINC(UDP_STAT_HDROPS);
                 return;                  return;
         }          }
         KASSERT(UDP_HDR_ALIGNED_P(uh));          KASSERT(UDP_HDR_ALIGNED_P(uh));
Line 372  udp_input(struct mbuf *m, ...)
Line 375  udp_input(struct mbuf *m, ...)
         len = ntohs((u_int16_t)uh->uh_ulen);          len = ntohs((u_int16_t)uh->uh_ulen);
         if (ip_len != iphlen + len) {          if (ip_len != iphlen + len) {
                 if (ip_len < iphlen + len || len < sizeof(struct udphdr)) {                  if (ip_len < iphlen + len || len < sizeof(struct udphdr)) {
                         udpstat[UDP_STAT_BADLEN]++;                          UDP_STATINC(UDP_STAT_BADLEN);
                         goto bad;                          goto bad;
                 }                  }
                 m_adj(m, iphlen + len - ip_len);                  m_adj(m, iphlen + len - ip_len);
Line 389  udp_input(struct mbuf *m, ...)
Line 392  udp_input(struct mbuf *m, ...)
         sockaddr_in_init(&dst, &ip->ip_dst, uh->uh_dport);          sockaddr_in_init(&dst, &ip->ip_dst, uh->uh_dport);
   
         if ((n = udp4_realinput(&src, &dst, &m, iphlen)) == -1) {          if ((n = udp4_realinput(&src, &dst, &m, iphlen)) == -1) {
                 udpstat[UDP_STAT_HDROPS]++;                  UDP_STATINC(UDP_STAT_HDROPS);
                 return;                  return;
         }          }
 #ifdef INET6  #ifdef INET6
Line 417  udp_input(struct mbuf *m, ...)
Line 420  udp_input(struct mbuf *m, ...)
   
         if (n == 0) {          if (n == 0) {
                 if (m->m_flags & (M_BCAST | M_MCAST)) {                  if (m->m_flags & (M_BCAST | M_MCAST)) {
                         udpstat[UDP_STAT_NOPORTBCAST]++;                          UDP_STATINC(UDP_STAT_NOPORTBCAST);
                         goto bad;                          goto bad;
                 }                  }
                 udpstat[UDP_STAT_NOPORT]++;                  UDP_STATINC(UDP_STAT_NOPORT);
 #ifdef IPKDB  #ifdef IPKDB
                 if (checkipkdb(&ip->ip_src, uh->uh_sport, uh->uh_dport,                  if (checkipkdb(&ip->ip_src, uh->uh_sport, uh->uh_dport,
                                 m, iphlen + sizeof(struct udphdr),                                  m, iphlen + sizeof(struct udphdr),
Line 639  udp4_sendup(struct mbuf *m, int off /* o
Line 642  udp4_sendup(struct mbuf *m, int off /* o
                         if (opts)                          if (opts)
                                 m_freem(opts);                                  m_freem(opts);
                         so->so_rcv.sb_overflowed++;                          so->so_rcv.sb_overflowed++;
                         udpstat[UDP_STAT_FULLSOCK]++;                          UDP_STATINC(UDP_STAT_FULLSOCK);
                 } else                  } else
                         sorwakeup(so);                          sorwakeup(so);
         }          }
Line 779  udp4_realinput(struct sockaddr_in *src, 
Line 782  udp4_realinput(struct sockaddr_in *src, 
                  */                   */
                 inp = in_pcblookup_connect(&udbtable, *src4, *sport, *dst4, *dport);                  inp = in_pcblookup_connect(&udbtable, *src4, *sport, *dst4, *dport);
                 if (inp == 0) {                  if (inp == 0) {
                         udpstat[UDP_STAT_PCBHASHMISS]++;                          UDP_STATINC(UDP_STAT_PCBHASHMISS);
                         inp = in_pcblookup_bind(&udbtable, *dst4, *dport);                          inp = in_pcblookup_bind(&udbtable, *dst4, *dport);
                         if (inp == 0)                          if (inp == 0)
                                 return rcvcnt;                                  return rcvcnt;
Line 927  udp6_realinput(int af, struct sockaddr_i
Line 930  udp6_realinput(int af, struct sockaddr_i
                 in6p = in6_pcblookup_connect(&udbtable, &src6, sport, dst6,                  in6p = in6_pcblookup_connect(&udbtable, &src6, sport, dst6,
                     dport, 0);                      dport, 0);
                 if (in6p == 0) {                  if (in6p == 0) {
                         udpstat[UDP_STAT_PCBHASHMISS]++;                          UDP_STATINC(UDP_STAT_PCBHASHMISS);
                         in6p = in6_pcblookup_bind(&udbtable, dst6, dport, 0);                          in6p = in6_pcblookup_bind(&udbtable, dst6, dport, 0);
                         if (in6p == 0)                          if (in6p == 0)
                                 return rcvcnt;                                  return rcvcnt;
Line 1143  udp_output(struct mbuf *m, ...)
Line 1146  udp_output(struct mbuf *m, ...)
         ((struct ip *)ui)->ip_len = htons(sizeof (struct udpiphdr) + len);          ((struct ip *)ui)->ip_len = htons(sizeof (struct udpiphdr) + len);
         ((struct ip *)ui)->ip_ttl = inp->inp_ip.ip_ttl; /* XXX */          ((struct ip *)ui)->ip_ttl = inp->inp_ip.ip_ttl; /* XXX */
         ((struct ip *)ui)->ip_tos = inp->inp_ip.ip_tos; /* XXX */          ((struct ip *)ui)->ip_tos = inp->inp_ip.ip_tos; /* XXX */
         udpstat[UDP_STAT_OPACKETS]++;          UDP_STATINC(UDP_STAT_OPACKETS);
   
         return (ip_output(m, inp->inp_options, ro,          return (ip_output(m, inp->inp_options, ro,
             inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST),              inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST),
Line 1330  release:
Line 1333  release:
         return (error);          return (error);
 }  }
   
   static void
   udpstat_convert_to_user_cb(void *v1, void *v2, struct cpu_info *ci)
   {
           uint64_t *udpsc = v1;
           uint64_t *udps = v2;
           u_int i;
   
           for (i = 0; i < UDP_NSTATS; i++)
                   udps[i] += udpsc[i];
   }
   
   static void
   udpstat_convert_to_user(uint64_t *udps)
   {
   
           memset(udps, 0, sizeof(uint64_t) * UDP_NSTATS);
           percpu_foreach(udpstat_percpu, udpstat_convert_to_user_cb, udps);
   }
   
   static int
   sysctl_net_inet_udp_stats(SYSCTLFN_ARGS)
   {
           struct sysctlnode node;
           uint64_t udps[UDP_NSTATS];
   
           udpstat_convert_to_user(udps);
           node = *rnode;
           node.sysctl_data = udps;
           node.sysctl_size = sizeof(udps);
           return (sysctl_lookup(SYSCTLFN_CALL(&node)));
   }
   
 /*  /*
  * Sysctl for udp variables.   * Sysctl for udp variables.
  */   */
Line 1392  SYSCTL_SETUP(sysctl_net_inet_udp_setup, 
Line 1427  SYSCTL_SETUP(sysctl_net_inet_udp_setup, 
                        CTLFLAG_PERMANENT,                         CTLFLAG_PERMANENT,
                        CTLTYPE_STRUCT, "stats",                         CTLTYPE_STRUCT, "stats",
                        SYSCTL_DESCR("UDP statistics"),                         SYSCTL_DESCR("UDP statistics"),
                        NULL, 0, udpstat, sizeof(udpstat),                         sysctl_net_inet_udp_stats, 0, NULL, 0,
                        CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_STATS,                         CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_STATS,
                        CTL_EOL);                         CTL_EOL);
 }  }
 #endif  #endif
   
   void
   udp_statinc(u_int stat)
   {
   
           KASSERT(stat < UDP_NSTATS);
           UDP_STATINC(stat);
   }
   
 #if (defined INET && defined IPSEC_NAT_T)  #if (defined INET && defined IPSEC_NAT_T)
 /*  /*
  * Returns:   * Returns:

Legend:
Removed from v.1.165  
changed lines
  Added in v.1.166

CVSweb <webmaster@jp.NetBSD.org>