[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.75.2.9 and 1.76

version 1.75.2.9, 2002/08/27 23:48:07 version 1.76, 2001/05/08 10:15:14
Line 3 
Line 3 
 /*  /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.   * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * All rights reserved.   * 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
  * are met:   * are met:
Line 15 
Line 15 
  * 3. Neither the name of the project nor the names of its contributors   * 3. Neither the name of the project nor the names of its contributors
  *    may be used to endorse or promote products derived from this software   *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.   *    without specific prior written permission.
  *   *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND   * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
Line 64 
Line 64 
  *      @(#)udp_usrreq.c        8.6 (Berkeley) 5/23/95   *      @(#)udp_usrreq.c        8.6 (Berkeley) 5/23/95
  */   */
   
 #include <sys/cdefs.h>  
 __KERNEL_RCSID(0, "$NetBSD$");  
   
 #include "opt_inet.h"  
 #include "opt_ipsec.h"  #include "opt_ipsec.h"
 #include "opt_inet_csum.h"  
 #include "opt_ipkdb.h"  #include "opt_ipkdb.h"
   
 #include <sys/param.h>  #include <sys/param.h>
Line 83  __KERNEL_RCSID(0, "$NetBSD$");
Line 78  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/domain.h>  #include <sys/domain.h>
   
   #include <uvm/uvm_extern.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   
 #include <net/if.h>  #include <net/if.h>
Line 139  int udpcksum = 1;
Line 136  int udpcksum = 1;
 int     udpcksum = 0;           /* XXX */  int     udpcksum = 0;           /* XXX */
 #endif  #endif
   
 struct  inpcbtable udbtable;  
 struct  udpstat udpstat;  
   
 #ifdef INET  #ifdef INET
 static void udp4_sendup __P((struct mbuf *, int, struct sockaddr *,  static void udp4_sendup __P((struct mbuf *, int, struct sockaddr *,
         struct socket *));          struct socket *));
Line 151  static int udp4_realinput __P((struct so
Line 145  static int udp4_realinput __P((struct so
 #ifdef INET6  #ifdef INET6
 static void udp6_sendup __P((struct mbuf *, int, struct sockaddr *,  static void udp6_sendup __P((struct mbuf *, int, struct sockaddr *,
         struct socket *));          struct socket *));
   static  int in6_mcmatch __P((struct in6pcb *, struct in6_addr *,
           struct ifnet *));
 static int udp6_realinput __P((int, struct sockaddr_in6 *,  static int udp6_realinput __P((int, struct sockaddr_in6 *,
         struct sockaddr_in6 *, struct mbuf *, int));          struct sockaddr_in6 *, struct mbuf *, int));
 #endif  #endif
Line 163  static void udp_notify __P((struct inpcb
Line 159  static void udp_notify __P((struct inpcb
 #endif  #endif
 int     udbhashsize = UDBHASHSIZE;  int     udbhashsize = UDBHASHSIZE;
   
 #ifdef UDP_CSUM_COUNTERS  
 #include <sys/device.h>  
   
 struct evcnt udp_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,  
     NULL, "udp", "hwcsum bad");  
 struct evcnt udp_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,  
     NULL, "udp", "hwcsum ok");  
 struct evcnt udp_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,  
     NULL, "udp", "hwcsum data");  
 struct evcnt udp_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,  
     NULL, "udp", "swcsum");  
   
 #define UDP_CSUM_COUNTER_INCR(ev)       (ev)->ev_count++  
   
 #else  
   
 #define UDP_CSUM_COUNTER_INCR(ev)       /* nothing */  
   
 #endif /* UDP_CSUM_COUNTERS */  
   
 void  void
 udp_init()  udp_init()
 {  {
Line 190  udp_init()
Line 166  udp_init()
 #ifdef INET  #ifdef INET
         in_pcbinit(&udbtable, udbhashsize, udbhashsize);          in_pcbinit(&udbtable, udbhashsize, udbhashsize);
 #endif  #endif
   
 #ifdef UDP_CSUM_COUNTERS  
         evcnt_attach_static(&udp_hwcsum_bad);  
         evcnt_attach_static(&udp_hwcsum_ok);  
         evcnt_attach_static(&udp_hwcsum_data);  
         evcnt_attach_static(&udp_swcsum);  
 #endif /* UDP_CSUM_COUNTERS */  
 }  }
   
   #ifndef UDP6
 #ifdef INET  #ifdef INET
 void  void
 #if __STDC__  #if __STDC__
Line 216  udp_input(m, va_alist)
Line 186  udp_input(m, va_alist)
         int iphlen, proto;          int iphlen, proto;
         int len;          int len;
         int n;          int n;
         u_int16_t ip_len;  
   
         va_start(ap, m);          va_start(ap, m);
         iphlen = va_arg(ap, int);          iphlen = va_arg(ap, int);
Line 263  udp_input(m, va_alist)
Line 232  udp_input(m, va_alist)
                 return;                  return;
         }          }
 #endif  #endif
         KASSERT(UDP_HDR_ALIGNED_P(uh));  
   
         /* destination port of 0 is illegal, based on RFC768. */          /* destination port of 0 is illegal, based on RFC768. */
         if (uh->uh_dport == 0)          if (uh->uh_dport == 0)
Line 273  udp_input(m, va_alist)
Line 241  udp_input(m, va_alist)
          * Make mbuf data length reflect UDP length.           * Make mbuf data length reflect UDP length.
          * If not enough data to reflect UDP length, drop.           * If not enough data to reflect UDP length, drop.
          */           */
         ip_len = ntohs(ip->ip_len);  
         len = ntohs((u_int16_t)uh->uh_ulen);          len = ntohs((u_int16_t)uh->uh_ulen);
         if (ip_len != iphlen + len) {          if (ip->ip_len != iphlen + len) {
                 if (ip_len < iphlen + len || len < sizeof(struct udphdr)) {                  if (ip->ip_len < iphlen + len || len < sizeof(struct udphdr)) {
                         udpstat.udps_badlen++;                          udpstat.udps_badlen++;
                         goto bad;                          goto bad;
                 }                  }
                 m_adj(m, iphlen + len - ip_len);                  m_adj(m, iphlen + len - ip->ip_len);
         }          }
   
         /*          /*
          * Checksum extended UDP header and data.           * Checksum extended UDP header and data.
          */           */
         if (uh->uh_sum) {          if (uh->uh_sum) {
                 switch (m->m_pkthdr.csum_flags &                  if (in4_cksum(m, IPPROTO_UDP, iphlen, len) != 0) {
                         ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv4) |                          udpstat.udps_badsum++;
                          M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {                          m_freem(m);
                 case M_CSUM_UDPv4|M_CSUM_TCP_UDP_BAD:                          return;
                         UDP_CSUM_COUNTER_INCR(&udp_hwcsum_bad);  
                         goto badcsum;  
   
                 case M_CSUM_UDPv4|M_CSUM_DATA:  
                         UDP_CSUM_COUNTER_INCR(&udp_hwcsum_data);  
                         if ((m->m_pkthdr.csum_data ^ 0xffff) != 0)  
                                 goto badcsum;  
                         break;  
   
                 case M_CSUM_UDPv4:  
                         /* Checksum was okay. */  
                         UDP_CSUM_COUNTER_INCR(&udp_hwcsum_ok);  
                         break;  
   
                 default:  
                         /* Need to compute it ourselves. */  
                         UDP_CSUM_COUNTER_INCR(&udp_swcsum);  
                         if (in4_cksum(m, IPPROTO_UDP, iphlen, len) != 0)  
                                 goto badcsum;  
                         break;  
                 }                  }
         }          }
   
Line 374  udp_input(m, va_alist)
Line 321  udp_input(m, va_alist)
 bad:  bad:
         if (m)          if (m)
                 m_freem(m);                  m_freem(m);
         return;  
   
 badcsum:  
         m_freem(m);  
         udpstat.udps_badsum++;  
 }  }
 #endif  #endif
   
Line 421  udp6_input(mp, offp, proto)
Line 363  udp6_input(mp, offp, proto)
                 return IPPROTO_DONE;                  return IPPROTO_DONE;
         }          }
 #endif  #endif
         KASSERT(UDP_HDR_ALIGNED_P(uh));  
         ulen = ntohs((u_short)uh->uh_ulen);          ulen = ntohs((u_short)uh->uh_ulen);
         /*          /*
          * RFC2675 section 4: jumbograms will have 0 in the UDP header field,           * RFC2675 section 4: jumbograms will have 0 in the UDP header field,
Line 541  udp4_sendup(m, off, src, so)
Line 482  udp4_sendup(m, off, src, so)
                         m_freem(n);                          m_freem(n);
                         if (opts)                          if (opts)
                                 m_freem(opts);                                  m_freem(opts);
                         udpstat.udps_fullsock++;  
                 } else                  } else
                         sorwakeup(so);                          sorwakeup(so);
         }          }
Line 637  udp4_realinput(src, dst, m, off)
Line 577  udp4_realinput(src, dst, m, off)
                  */                   */
   
                 /*                  /*
                  * KAME note: traditionally we dropped udpiphdr from mbuf here.                   * KAME note: usually we drop udpiphdr from mbuf here.
                  * we need udpiphdr for IPsec processing so we do that later.                   * we need udpiphdr for IPsec processing so we do that later.
                  */                   */
                 /*                  /*
                  * Locate pcb(s) for datagram.                   * Locate pcb(s) for datagram.
                  */                   */
                 CIRCLEQ_FOREACH(inp, &udbtable.inpt_queue, inp_queue) {                  for (inp = udbtable.inpt_queue.cqh_first;
                       inp != (struct inpcb *)&udbtable.inpt_queue;
                       inp = inp->inp_queue.cqe_next) {
                         if (inp->inp_lport != *dport)                          if (inp->inp_lport != *dport)
                                 continue;                                  continue;
                         if (!in_nullhost(inp->inp_laddr)) {                          if (!in_nullhost(inp->inp_laddr)) {
Line 673  udp4_realinput(src, dst, m, off)
Line 615  udp4_realinput(src, dst, m, off)
                             (SO_REUSEPORT|SO_REUSEADDR)) == 0)                              (SO_REUSEPORT|SO_REUSEADDR)) == 0)
                                 break;                                  break;
                 }                  }
   
   #if 0
                   if (last == NULL) {
                           /*
                            * No matching pcb found; discard datagram.
                            * (No need to send an ICMP Port Unreachable
                            * for a broadcast or multicast datgram.)
                            */
                           udpstat.udps_noportbcast++;
                           goto bad;
                   }
   #endif
         } else {          } else {
                 /*                  /*
                  * Locate pcb for datagram.                   * Locate pcb for datagram.
Line 681  udp4_realinput(src, dst, m, off)
Line 635  udp4_realinput(src, dst, m, off)
                 if (inp == 0) {                  if (inp == 0) {
                         ++udpstat.udps_pcbhashmiss;                          ++udpstat.udps_pcbhashmiss;
                         inp = in_pcblookup_bind(&udbtable, *dst4, *dport);                          inp = in_pcblookup_bind(&udbtable, *dst4, *dport);
                         if (inp == 0)                          if (inp == 0) {
   #if 0
                                   struct mbuf *n;
   
                                   if (m->m_flags & (M_BCAST | M_MCAST)) {
                                           udpstat.udps_noportbcast++;
                                           goto bad;
                                   }
                                   udpstat.udps_noport++;
   #ifdef IPKDB
                                   if (checkipkdb(src4, *sport, *dport, m, off,
                                                  m->m_pkthdr.len - off)) {
                                           /*
                                            * It was a debugger connect packet,
                                            * just drop it now
                                            */
                                           goto bad;
                                   }
   #endif
                                   if ((n = m_copy(m, 0, M_COPYALL)) != NULL) {
                                           icmp_error(n, ICMP_UNREACH,
                                                   ICMP_UNREACH_PORT, 0, 0);
                                   }
   #endif
                                 return rcvcnt;                                  return rcvcnt;
                           }
                 }                  }
   
                 udp4_sendup(m, off, (struct sockaddr *)src, inp->inp_socket);                  udp4_sendup(m, off, (struct sockaddr *)src, inp->inp_socket);
Line 696  bad:
Line 674  bad:
   
 #ifdef INET6  #ifdef INET6
 static int  static int
   in6_mcmatch(in6p, ia6, ifp)
           struct in6pcb *in6p;
           struct in6_addr *ia6;
           struct ifnet *ifp;
   {
           struct ip6_moptions *im6o = in6p->in6p_moptions;
           struct in6_multi_mship *imm;
   
           if (im6o == NULL)
                   return 0;
   
           for (imm = im6o->im6o_memberships.lh_first; imm != NULL;
                imm = imm->i6mm_chain.le_next) {
                   if ((ifp == NULL ||
                        imm->i6mm_maddr->in6m_ifp == ifp) &&
                       IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
                                          ia6))
                           return 1;
           }
           return 0;
   }
   
   static int
 udp6_realinput(af, src, dst, m, off)  udp6_realinput(af, src, dst, m, off)
         int af;         /* af on packet */          int af;         /* af on packet */
         struct sockaddr_in6 *src;          struct sockaddr_in6 *src;
Line 703  udp6_realinput(af, src, dst, m, off)
Line 704  udp6_realinput(af, src, dst, m, off)
         struct mbuf *m;          struct mbuf *m;
         int off;        /* offset of udphdr */          int off;        /* offset of udphdr */
 {  {
         u_int16_t sport, dport;          u_int16_t *sport, *dport;
         int rcvcnt;          int rcvcnt;
         struct in6_addr src6, dst6;          struct in6_addr *src6, *dst6;
         const struct in_addr *dst4;          struct in_addr *dst4;
         struct in6pcb *in6p;          struct in6pcb *in6p;
   
         rcvcnt = 0;          rcvcnt = 0;
Line 717  udp6_realinput(af, src, dst, m, off)
Line 718  udp6_realinput(af, src, dst, m, off)
         if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)          if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)
                 goto bad;                  goto bad;
   
         in6_embedscope(&src6, src, NULL, NULL);          src6 = &src->sin6_addr;
         sport = src->sin6_port;          sport = &src->sin6_port;
         in6_embedscope(&dst6, dst, NULL, NULL);          dst6 = &dst->sin6_addr;
         dport = dst->sin6_port;          dport = &dst->sin6_port;
         dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[12];          dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr32[12];
   
         if (IN6_IS_ADDR_MULTICAST(&dst6) ||          if (IN6_IS_ADDR_MULTICAST(dst6)
             (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {           || (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {
                 struct in6pcb *last;                  struct in6pcb *last;
                 /*                  /*
                  * Deliver a multicast or broadcast datagram to *all* sockets                   * Deliver a multicast or broadcast datagram to *all* sockets
Line 743  udp6_realinput(af, src, dst, m, off)
Line 744  udp6_realinput(af, src, dst, m, off)
                  */                   */
   
                 /*                  /*
                  * KAME note: traditionally we dropped udpiphdr from mbuf here.                   * KAME note: usually we drop udpiphdr from mbuf here.
                  * we need udpiphdr for IPsec processing so we do that later.                   * we need udpiphdr for IPsec processing so we do that later.
                  */                   */
                 /*                  /*
Line 751  udp6_realinput(af, src, dst, m, off)
Line 752  udp6_realinput(af, src, dst, m, off)
                  */                   */
                 for (in6p = udb6.in6p_next; in6p != &udb6;                  for (in6p = udb6.in6p_next; in6p != &udb6;
                      in6p = in6p->in6p_next) {                       in6p = in6p->in6p_next) {
                         if (in6p->in6p_lport != dport)                          if (in6p->in6p_lport != *dport)
                                 continue;                                  continue;
                         if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {                          if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {
                                 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &dst6))                                  if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, dst6)
                                    && !in6_mcmatch(in6p, dst6, m->m_pkthdr.rcvif))
                                         continue;                                          continue;
                         } else {                          }
                                 if (IN6_IS_ADDR_V4MAPPED(&dst6) &&  #ifndef INET6_BINDV6ONLY
                                     (in6p->in6p_flags & IN6P_IPV6_V6ONLY))                          else {
                                   if (IN6_IS_ADDR_V4MAPPED(dst6)
                                    && (in6p->in6p_flags & IN6P_BINDV6ONLY))
                                         continue;                                          continue;
                         }                          }
   #endif
                         if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {                          if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
                                 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr,                                  if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, src6)
                                     &src6) || in6p->in6p_fport != sport)                                   || in6p->in6p_fport != *sport)
                                         continue;                                          continue;
                         } else {                          }
                                 if (IN6_IS_ADDR_V4MAPPED(&src6) &&  #ifndef INET6_BINDV6ONLY
                                     (in6p->in6p_flags & IN6P_IPV6_V6ONLY))                          else {
                                   if (IN6_IS_ADDR_V4MAPPED(src6)
                                    && (in6p->in6p_flags & IN6P_BINDV6ONLY))
                                         continue;                                          continue;
                         }                          }
   #endif
   
                         last = in6p;                          last = in6p;
                         udp6_sendup(m, off, (struct sockaddr *)src,                          udp6_sendup(m, off, (struct sockaddr *)src,
Line 788  udp6_realinput(af, src, dst, m, off)
Line 796  udp6_realinput(af, src, dst, m, off)
                             (SO_REUSEPORT|SO_REUSEADDR)) == 0)                              (SO_REUSEPORT|SO_REUSEADDR)) == 0)
                                 break;                                  break;
                 }                  }
   
   #if 0
                   if (last == NULL) {
                           /*
                            * No matching pcb found; discard datagram.
                            * (No need to send an ICMP Port Unreachable
                            * for a broadcast or multicast datgram.)
                            */
                           switch (af) {
                           case AF_INET:
                                   udpstat.udps_noportbcast++;
                                   break;
                           case AF_INET6:
                                   udp6stat.udp6s_noportmcast++;
                                   break;
                           }
                           goto bad;
                   }
   #endif
         } else {          } else {
                 /*                  /*
                  * Locate pcb for datagram.                   * Locate pcb for datagram.
                  */                   */
                 in6p = in6_pcblookup_connect(&udb6, &src6, sport,                  in6p = in6_pcblookup_connect(&udb6, src6, *sport,
                     &dst6, dport, 0);                          dst6, *dport, 0);
                 if (in6p == 0) {                  if (in6p == 0) {
                         ++udpstat.udps_pcbhashmiss;                          ++udpstat.udps_pcbhashmiss;
                         in6p = in6_pcblookup_bind(&udb6, &dst6, dport, 0);                          in6p = in6_pcblookup_bind(&udb6, dst6, *dport, 0);
                         if (in6p == 0)                          if (in6p == 0) {
   #if 0
                                   struct mbuf *n;
                                   n = m_copy(m, 0, M_COPYALL);
                                   switch (af) {
                                   case AF_INET:
                                           if (m->m_flags & (M_BCAST | M_MCAST)) {
                                                   udpstat.udps_noportbcast++;
                                                   goto bad;
                                           }
                                           udpstat.udps_noport++;
                                           if (n != NULL)
                                                   icmp_error(n, ICMP_UNREACH,
                                                       ICMP_UNREACH_PORT, 0, 0);
                                           break;
                                   case AF_INET6:
                                           if (m->m_flags & M_MCAST) {
                                                   udp6stat.udp6s_noportmcast++;
                                                   goto bad;
                                           }
                                           udp6stat.udp6s_noport++;
                                           if (n != NULL)
                                                   icmp6_error(n, ICMP6_DST_UNREACH,
                                                       ICMP6_DST_UNREACH_NOPORT, 0);
                                           break;
                                   }
   #endif
   
                                 return rcvcnt;                                  return rcvcnt;
                           }
                 }                  }
   
                 udp6_sendup(m, off, (struct sockaddr *)src, in6p->in6p_socket);                  udp6_sendup(m, off, (struct sockaddr *)src, in6p->in6p_socket);
Line 810  bad:
Line 865  bad:
 }  }
 #endif  #endif
   
   #else /*UDP6*/
   
   void
   #if __STDC__
   udp_input(struct mbuf *m, ...)
   #else
   udp_input(m, va_alist)
           struct mbuf *m;
           va_dcl
   #endif
   {
           int proto;
           struct ip *ip;
           struct udphdr *uh;
           struct inpcb *inp;
           struct mbuf *opts = 0;
           int len;
           struct ip save_ip;
           int iphlen;
           va_list ap;
           struct sockaddr_in udpsrc;
           struct sockaddr *sa;
   
           va_start(ap, m);
           iphlen = va_arg(ap, int);
           proto = va_arg(ap, int);
           va_end(ap);
   
           udpstat.udps_ipackets++;
   
           /*
            * Strip IP options, if any; should skip this,
            * make available to user, and use on returned packets,
            * but we don't yet have a way to check the checksum
            * with options still present.
            */
           if (iphlen > sizeof (struct ip)) {
                   ip_stripoptions(m, (struct mbuf *)0);
                   iphlen = sizeof(struct ip);
           }
   
           /*
            * Get IP and UDP header together in first mbuf.
            */
           ip = mtod(m, struct ip *);
           if (m->m_len < iphlen + sizeof(struct udphdr)) {
                   if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {
                           udpstat.udps_hdrops++;
                           return;
                   }
                   ip = mtod(m, struct ip *);
           }
           uh = (struct udphdr *)((caddr_t)ip + iphlen);
   
           /* destination port of 0 is illegal, based on RFC768. */
           if (uh->uh_dport == 0)
                   goto bad;
   
           /*
            * Make mbuf data length reflect UDP length.
            * If not enough data to reflect UDP length, drop.
            */
           len = ntohs((u_int16_t)uh->uh_ulen);
           if (ip->ip_len != iphlen + len) {
                   if (ip->ip_len < iphlen + len || len < sizeof(struct udphdr)) {
                           udpstat.udps_badlen++;
                           goto bad;
                   }
                   m_adj(m, iphlen + len - ip->ip_len);
           }
           /*
            * Save a copy of the IP header in case we want restore it
            * for sending an ICMP error message in response.
            */
           save_ip = *ip;
   
           /*
            * Checksum extended UDP header and data.
            */
           if (uh->uh_sum) {
                   bzero(((struct ipovly *)ip)->ih_x1,
                       sizeof ((struct ipovly *)ip)->ih_x1);
                   ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
                   if (in_cksum(m, len + sizeof (struct ip)) != 0) {
                           udpstat.udps_badsum++;
                           m_freem(m);
                           return;
                   }
           }
   
           /*
            * Construct sockaddr format source address.
            */
           udpsrc.sin_family = AF_INET;
           udpsrc.sin_len = sizeof(struct sockaddr_in);
           udpsrc.sin_addr = ip->ip_src;
           udpsrc.sin_port = uh->uh_sport;
           bzero((caddr_t)udpsrc.sin_zero, sizeof(udpsrc.sin_zero));
   
           if (IN_MULTICAST(ip->ip_dst.s_addr) ||
               in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) {
                   struct inpcb *last;
                   /*
                    * Deliver a multicast or broadcast datagram to *all* sockets
                    * for which the local and remote addresses and ports match
                    * those of the incoming datagram.  This allows more than
                    * one process to receive multi/broadcasts on the same port.
                    * (This really ought to be done for unicast datagrams as
                    * well, but that would cause problems with existing
                    * applications that open both address-specific sockets and
                    * a wildcard socket listening to the same port -- they would
                    * end up receiving duplicates of every unicast datagram.
                    * Those applications open the multiple sockets to overcome an
                    * inadequacy of the UDP socket interface, but for backwards
                    * compatibility we avoid the problem here rather than
                    * fixing the interface.  Maybe 4.5BSD will remedy this?)
                    */
   
                   iphlen += sizeof(struct udphdr);
                   /*
                    * KAME note: usually we drop udpiphdr from mbuf here.
                    * we need udpiphdr for IPsec processing so we do that later.
                    */
                   /*
                    * Locate pcb(s) for datagram.
                    * (Algorithm copied from raw_intr().)
                    */
                   last = NULL;
                   for (inp = udbtable.inpt_queue.cqh_first;
                       inp != (struct inpcb *)&udbtable.inpt_queue;
                       inp = inp->inp_queue.cqe_next) {
                           if (inp->inp_lport != uh->uh_dport)
                                   continue;
                           if (!in_nullhost(inp->inp_laddr)) {
                                   if (!in_hosteq(inp->inp_laddr, ip->ip_dst))
                                           continue;
                           }
                           if (!in_nullhost(inp->inp_faddr)) {
                                   if (!in_hosteq(inp->inp_faddr, ip->ip_src) ||
                                       inp->inp_fport != uh->uh_sport)
                                           continue;
                           }
   
                           if (last != NULL) {
                                   struct mbuf *n;
   
   #ifdef IPSEC
                                   /* check AH/ESP integrity. */
                                   if (last != NULL && ipsec4_in_reject(m, last)) {
                                           ipsecstat.in_polvio++;
                                           /* do not inject data to pcb */
                                   } else
   #endif /*IPSEC*/
                                   if ((n = m_copy(m, 0, M_COPYALL)) != NULL) {
                                           if (last->inp_flags & INP_CONTROLOPTS
                                               || last->inp_socket->so_options &
                                                  SO_TIMESTAMP) {
                                                   ip_savecontrol(last, &opts,
                                                       ip, n);
                                           }
                                           m_adj(n, iphlen);
                                           sa = (struct sockaddr *)&udpsrc;
                                           if (sbappendaddr(
                                               &last->inp_socket->so_rcv,
                                               sa, n, opts) == 0) {
                                                   m_freem(n);
                                                   if (opts)
                                                           m_freem(opts);
                                           } else
                                                   sorwakeup(last->inp_socket);
                                           opts = 0;
                                   }
                           }
                           last = inp;
                           /*
                            * Don't look for additional matches if this one does
                            * not have either the SO_REUSEPORT or SO_REUSEADDR
                            * socket options set.  This heuristic avoids searching
                            * through all pcbs in the common case of a non-shared
                            * port.  It * assumes that an application will never
                            * clear these options after setting them.
                            */
                           if ((last->inp_socket->so_options &
                               (SO_REUSEPORT|SO_REUSEADDR)) == 0)
                                   break;
                   }
   
                   if (last == NULL) {
                           /*
                            * No matching pcb found; discard datagram.
                            * (No need to send an ICMP Port Unreachable
                            * for a broadcast or multicast datgram.)
                            */
                           udpstat.udps_noportbcast++;
                           goto bad;
                   }
   #ifdef IPSEC
                   /* check AH/ESP integrity. */
                   if (last != NULL && ipsec4_in_reject(m, last)) {
                           ipsecstat.in_polvio++;
                           goto bad;
                   }
   #endif /*IPSEC*/
                   if (last->inp_flags & INP_CONTROLOPTS ||
                       last->inp_socket->so_options & SO_TIMESTAMP)
                           ip_savecontrol(last, &opts, ip, m);
                   m->m_len -= iphlen;
                   m->m_pkthdr.len -= iphlen;
                   m->m_data += iphlen;
                   sa = (struct sockaddr *)&udpsrc;
                   if (sbappendaddr(&last->inp_socket->so_rcv, sa, m, opts) == 0) {
                           udpstat.udps_fullsock++;
                           goto bad;
                   }
                   sorwakeup(last->inp_socket);
                   return;
           }
           /*
            * Locate pcb for datagram.
            */
           inp = in_pcblookup_connect(&udbtable, ip->ip_src, uh->uh_sport,
               ip->ip_dst, uh->uh_dport);
           if (inp == 0) {
                   ++udpstat.udps_pcbhashmiss;
                   inp = in_pcblookup_bind(&udbtable, ip->ip_dst, uh->uh_dport);
                   if (inp == 0) {
                           if (m->m_flags & (M_BCAST | M_MCAST)) {
                                   udpstat.udps_noportbcast++;
                                   goto bad;
                           }
                           udpstat.udps_noport++;
                           *ip = save_ip;
   #ifdef IPKDB
                           if (checkipkdb(&ip->ip_src,
                                          uh->uh_sport,
                                          uh->uh_dport,
                                          m,
                                          iphlen + sizeof(struct udphdr),
                                          len - sizeof(struct udphdr)))
                           /* It was a debugger connect packet, just drop it now */
                                   goto bad;
   #endif
                           icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0);
                           return;
                   }
           }
   #ifdef IPSEC
           if (inp != NULL && ipsec4_in_reject(m, inp)) {
                   ipsecstat.in_polvio++;
                   goto bad;
           }
   #endif /*IPSEC*/
   
           /*
            * Stuff source address and datagram in user buffer.
            */
           if (inp->inp_flags & INP_CONTROLOPTS ||
               inp->inp_socket->so_options & SO_TIMESTAMP)
                   ip_savecontrol(inp, &opts, ip, m);
           iphlen += sizeof(struct udphdr);
           m->m_len -= iphlen;
           m->m_pkthdr.len -= iphlen;
           m->m_data += iphlen;
           sa = (struct sockaddr *)&udpsrc;
           if (sbappendaddr(&inp->inp_socket->so_rcv, sa, m, opts) == 0) {
                   udpstat.udps_fullsock++;
                   goto bad;
           }
           sorwakeup(inp->inp_socket);
           return;
   bad:
           m_freem(m);
           if (opts)
                   m_freem(opts);
   }
   #endif /*UDP6*/
   
 #ifdef INET  #ifdef INET
 /*  /*
  * Notify a udp user of an asynchronous error;   * Notify a udp user of an asynchronous error;
Line 894  udp_output(m, va_alist)
Line 1226  udp_output(m, va_alist)
          * Compute the packet length of the IP header, and           * Compute the packet length of the IP header, and
          * punt if the length looks bogus.           * punt if the length looks bogus.
          */           */
         if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) {          if ((len + sizeof(struct udpiphdr)) > IP_MAXPACKET) {
                 error = EMSGSIZE;                  error = EMSGSIZE;
                 goto release;                  goto release;
         }          }
Line 904  udp_output(m, va_alist)
Line 1236  udp_output(m, va_alist)
          * and addresses and length put into network format.           * and addresses and length put into network format.
          */           */
         ui = mtod(m, struct udpiphdr *);          ui = mtod(m, struct udpiphdr *);
           bzero(ui->ui_x1, sizeof ui->ui_x1);
         ui->ui_pr = IPPROTO_UDP;          ui->ui_pr = IPPROTO_UDP;
           ui->ui_len = htons((u_int16_t)len + sizeof (struct udphdr));
         ui->ui_src = inp->inp_laddr;          ui->ui_src = inp->inp_laddr;
         ui->ui_dst = inp->inp_faddr;          ui->ui_dst = inp->inp_faddr;
         ui->ui_sport = inp->inp_lport;          ui->ui_sport = inp->inp_lport;
         ui->ui_dport = inp->inp_fport;          ui->ui_dport = inp->inp_fport;
         ui->ui_ulen = htons((u_int16_t)len + sizeof(struct udphdr));          ui->ui_ulen = ui->ui_len;
   
         /*          /*
          * Set up checksum and output datagram.           * Stuff checksum and output datagram.
          */           */
           ui->ui_sum = 0;
         if (udpcksum) {          if (udpcksum) {
                 /*              if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0)
                  * XXX Cache pseudo-header checksum part for                  ui->ui_sum = 0xffff;
                  * XXX "connected" UDP sockets.          }
                  */          ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
                 ui->ui_sum = in_cksum_phdr(ui->ui_src.s_addr,  
                     ui->ui_dst.s_addr, htons((u_int16_t)len +  
                     sizeof(struct udphdr) + IPPROTO_UDP));  
                 m->m_pkthdr.csum_flags = M_CSUM_UDPv4;  
                 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);  
         } else  
                 ui->ui_sum = 0;  
         ((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.udps_opackets++;          udpstat.udps_opackets++;
Line 968  udp_usrreq(so, req, m, nam, control, p)
Line 1295  udp_usrreq(so, req, m, nam, control, p)
                     (struct ifnet *)control, p));                      (struct ifnet *)control, p));
   
         if (req == PRU_PURGEIF) {          if (req == PRU_PURGEIF) {
                 in_pcbpurgeif0(&udbtable, (struct ifnet *)control);  
                 in_purgeif((struct ifnet *)control);                  in_purgeif((struct ifnet *)control);
                 in_pcbpurgeif(&udbtable, (struct ifnet *)control);                  in_pcbpurgeif(&udbtable, (struct ifnet *)control);
                 return (0);                  return (0);
Line 1006  udp_usrreq(so, req, m, nam, control, p)
Line 1332  udp_usrreq(so, req, m, nam, control, p)
                         break;                          break;
                 inp = sotoinpcb(so);                  inp = sotoinpcb(so);
                 inp->inp_ip.ip_ttl = ip_defttl;                  inp->inp_ip.ip_ttl = ip_defttl;
   #ifdef IPSEC
                   error = ipsec_init_policy(so, &inp->inp_sp);
                   if (error != 0) {
                           in_pcbdetach(inp);
                           break;
                   }
   #endif /*IPSEC*/
                 break;                  break;
   
         case PRU_DETACH:          case PRU_DETACH:
Line 1141  udp_sysctl(name, namelen, oldp, oldlenp,
Line 1474  udp_sysctl(name, namelen, oldp, oldlenp,
                 return (sysctl_int(oldp, oldlenp, newp, newlen,                  return (sysctl_int(oldp, oldlenp, newp, newlen,
                     &udp_sendspace));                      &udp_sendspace));
         case UDPCTL_RECVSPACE:          case UDPCTL_RECVSPACE:
                 return (sysctl_int(oldp, oldlenp, newp, newlen,                  return (sysctl_int(oldp, oldlenp, newp, newlen,
                     &udp_recvspace));                      &udp_recvspace));
         default:          default:
                 return (ENOPROTOOPT);                  return (ENOPROTOOPT);
Legend:
Removed from v.1.75.2.9  
changed lines
  Added in v.1.76
CVSweb <webmaster@jp.NetBSD.org>