[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.84 and 1.113

version 1.84, 2001/09/17 17:27:01 version 1.113, 2003/10/23 20:55:08
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 41 
Line 41 
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software   * 3. Neither the name of the University nor the names of its contributors
  *    must display the following acknowledgement:  
  *      This product includes software developed by the University of  
  *      California, Berkeley and its contributors.  
  * 4. Neither the name of the University 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.
  *   *
Line 64 
Line 60 
  *      @(#)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_inet.h"
 #include "opt_ipsec.h"  #include "opt_ipsec.h"
 #include "opt_inet_csum.h"  #include "opt_inet_csum.h"
 #include "opt_ipkdb.h"  #include "opt_ipkdb.h"
   #include "opt_mbuftrace.h"
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/malloc.h>  #include <sys/malloc.h>
Line 80 
Line 80 
 #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 105 
Line 103 
 #include <netinet6/udp6_var.h>  #include <netinet6/udp6_var.h>
 #endif  #endif
   
 #ifdef PULLDOWN_TEST  
 #ifndef INET6  #ifndef INET6
 /* always need ip6.h for IP6_EXTHDR_GET */  /* always need ip6.h for IP6_EXTHDR_GET */
 #include <netinet/ip6.h>  #include <netinet/ip6.h>
 #endif  #endif
 #endif  
   
 #include "faith.h"  #include "faith.h"
 #if defined(NFAITH) && NFAITH > 0  #if defined(NFAITH) && NFAITH > 0
Line 119 
Line 115 
   
 #include <machine/stdarg.h>  #include <machine/stdarg.h>
   
   #ifdef FAST_IPSEC
   #include <netipsec/ipsec.h>
   #ifdef INET6
   #include <netipsec/ipsec6.h>
   #endif
   #endif  /* FAST_IPSEC*/
   
 #ifdef IPSEC  #ifdef IPSEC
 #include <netinet6/ipsec.h>  #include <netinet6/ipsec.h>
 #include <netkey/key.h>  #include <netkey/key.h>
Line 138  int udpcksum = 1;
Line 141  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 147  static int udp4_realinput __P((struct so
Line 153  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 161  static void udp_notify __P((struct inpcb
Line 165  static void udp_notify __P((struct inpcb
 #endif  #endif
 int     udbhashsize = UDBHASHSIZE;  int     udbhashsize = UDBHASHSIZE;
   
   #ifdef MBUFTRACE
   struct mowner udp_mowner = { "udp" };
   struct mowner udp_rx_mowner = { "udp", "rx" };
   struct mowner udp_tx_mowner = { "udp", "tx" };
   #endif
   
 #ifdef UDP_CSUM_COUNTERS  #ifdef UDP_CSUM_COUNTERS
 #include <sys/device.h>  #include <sys/device.h>
   
Line 185  void
Line 195  void
 udp_init()  udp_init()
 {  {
   
 #ifdef INET  
         in_pcbinit(&udbtable, udbhashsize, udbhashsize);          in_pcbinit(&udbtable, udbhashsize, udbhashsize);
 #endif  
   
 #ifdef UDP_CSUM_COUNTERS  #ifdef UDP_CSUM_COUNTERS
         evcnt_attach_static(&udp_hwcsum_bad);          evcnt_attach_static(&udp_hwcsum_bad);
Line 195  udp_init()
Line 203  udp_init()
         evcnt_attach_static(&udp_hwcsum_data);          evcnt_attach_static(&udp_hwcsum_data);
         evcnt_attach_static(&udp_swcsum);          evcnt_attach_static(&udp_swcsum);
 #endif /* UDP_CSUM_COUNTERS */  #endif /* UDP_CSUM_COUNTERS */
   
           MOWNER_ATTACH(&udp_tx_mowner);
           MOWNER_ATTACH(&udp_rx_mowner);
           MOWNER_ATTACH(&udp_mowner);
 }  }
   
 #ifndef UDP6  
 #ifdef INET  #ifdef INET
 void  void
 #if __STDC__  #if __STDC__
Line 212  udp_input(m, va_alist)
Line 223  udp_input(m, va_alist)
         struct sockaddr_in src, dst;          struct sockaddr_in src, dst;
         struct ip *ip;          struct ip *ip;
         struct udphdr *uh;          struct udphdr *uh;
         int iphlen, proto;          int iphlen;
         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);
         proto = va_arg(ap, int);          (void)va_arg(ap, int);          /* ignore value, advance ap */
         va_end(ap);          va_end(ap);
   
           MCLAIM(m, &udp_rx_mowner);
         udpstat.udps_ipackets++;          udpstat.udps_ipackets++;
   
 #ifndef PULLDOWN_TEST  
         /*  
          * 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);  
         }  
 #else  
         /*  
          * we may enable the above code if we save and pass IPv4 options  
          * to the userland.  
          */  
 #endif  
   
         /*          /*
          * Get IP and UDP header together in first mbuf.           * Get IP and UDP header together in first mbuf.
          */           */
         ip = mtod(m, struct ip *);          ip = mtod(m, struct ip *);
 #ifndef PULLDOWN_TEST  
         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);  
 #else  
         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.udps_hdrops++;                  udpstat.udps_hdrops++;
                 return;                  return;
         }          }
 #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 270  udp_input(m, va_alist)
Line 255  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->ip_len != iphlen + len) {          if (ip_len != iphlen + len) {
                 if (ip->ip_len < iphlen + len || len < sizeof(struct udphdr)) {                  if (ip_len < iphlen + len || len < sizeof(struct udphdr)) {
                         udpstat.udps_badlen++;                          udpstat.udps_badlen++;
                         goto bad;                          goto bad;
                 }                  }
                 m_adj(m, iphlen + len - ip->ip_len);                  m_adj(m, iphlen + len - ip_len);
         }          }
   
         /*          /*
Line 284  udp_input(m, va_alist)
Line 270  udp_input(m, va_alist)
          */           */
         if (uh->uh_sum) {          if (uh->uh_sum) {
                 switch (m->m_pkthdr.csum_flags &                  switch (m->m_pkthdr.csum_flags &
                         ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv4) |                      ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv4) |
                          M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {                      M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
                 case M_CSUM_UDPv4|M_CSUM_TCP_UDP_BAD:                  case M_CSUM_UDPv4|M_CSUM_TCP_UDP_BAD:
                         UDP_CSUM_COUNTER_INCR(&udp_hwcsum_bad);                          UDP_CSUM_COUNTER_INCR(&udp_hwcsum_bad);
                         goto badcsum;                          goto badcsum;
   
                 case M_CSUM_UDPv4|M_CSUM_DATA:                  case M_CSUM_UDPv4|M_CSUM_DATA: {
                           u_int32_t hw_csum = m->m_pkthdr.csum_data;
                         UDP_CSUM_COUNTER_INCR(&udp_hwcsum_data);                          UDP_CSUM_COUNTER_INCR(&udp_hwcsum_data);
                         if ((m->m_pkthdr.csum_data ^ 0xffff) != 0)                          if (m->m_pkthdr.csum_flags & M_CSUM_NO_PSEUDOHDR)
                                   hw_csum = in_cksum_phdr(ip->ip_src.s_addr,
                                       ip->ip_dst.s_addr,
                                       htonl(hw_csum + ntohs(ip->ip_len) +
                                       IPPROTO_UDP));
                           if ((hw_csum ^ 0xffff) != 0)
                                 goto badcsum;                                  goto badcsum;
                         break;                          break;
                   }
   
                 case M_CSUM_UDPv4:                  case M_CSUM_UDPv4:
                         /* Checksum was okay. */                          /* Checksum was okay. */
Line 391  udp6_input(mp, offp, proto)
Line 384  udp6_input(mp, offp, proto)
         struct udphdr *uh;          struct udphdr *uh;
         u_int32_t plen, ulen;          u_int32_t plen, ulen;
   
 #ifndef PULLDOWN_TEST  
         IP6_EXTHDR_CHECK(m, off, sizeof(struct udphdr), IPPROTO_DONE);  
 #endif  
         ip6 = mtod(m, struct ip6_hdr *);          ip6 = mtod(m, struct ip6_hdr *);
   
 #if defined(NFAITH) && 0 < NFAITH  #if defined(NFAITH) && 0 < NFAITH
Line 408  udp6_input(mp, offp, proto)
Line 398  udp6_input(mp, offp, proto)
   
         /* check for jumbogram is done in ip6_input.  we can trust pkthdr.len */          /* check for jumbogram is done in ip6_input.  we can trust pkthdr.len */
         plen = m->m_pkthdr.len - off;          plen = m->m_pkthdr.len - off;
 #ifndef PULLDOWN_TEST  
         uh = (struct udphdr *)((caddr_t)ip6 + off);  
 #else  
         IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));          IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));
         if (uh == NULL) {          if (uh == NULL) {
                 ip6stat.ip6s_tooshort++;                  ip6stat.ip6s_tooshort++;
                 return IPPROTO_DONE;                  return IPPROTO_DONE;
         }          }
 #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 496  udp4_sendup(m, off, src, so)
Line 483  udp4_sendup(m, off, src, so)
         struct mbuf *opts = NULL;          struct mbuf *opts = NULL;
         struct mbuf *n;          struct mbuf *n;
         struct inpcb *inp = NULL;          struct inpcb *inp = NULL;
 #ifdef INET6  
         struct in6pcb *in6p = NULL;  
 #endif  
   
         if (!so)          if (!so)
                 return;                  return;
Line 508  udp4_sendup(m, off, src, so)
Line 492  udp4_sendup(m, off, src, so)
                 break;                  break;
 #ifdef INET6  #ifdef INET6
         case AF_INET6:          case AF_INET6:
                 in6p = sotoin6pcb(so);  
                 break;                  break;
 #endif  #endif
         default:          default:
                 return;                  return;
         }          }
   
 #ifdef IPSEC  #if defined(IPSEC) || defined(FAST_IPSEC)
         /* check AH/ESP integrity. */          /* check AH/ESP integrity. */
         if (so != NULL && ipsec4_in_reject_so(m, so)) {          if (so != NULL && ipsec4_in_reject_so(m, so)) {
                 ipsecstat.in_polvio++;                  ipsecstat.in_polvio++;
                   if ((n = m_copy(m, 0, M_COPYALL)) != NULL)
                           icmp_error(n, ICMP_UNREACH, ICMP_UNREACH_ADMIN_PROHIBIT,
                               0, 0);
                 return;                  return;
         }          }
 #endif /*IPSEC*/  #endif /*IPSEC*/
Line 561  udp6_sendup(m, off, src, so)
Line 547  udp6_sendup(m, off, src, so)
                 return;                  return;
         in6p = sotoin6pcb(so);          in6p = sotoin6pcb(so);
   
 #ifdef IPSEC  #if defined(IPSEC) || defined(FAST_IPSEC)
         /* check AH/ESP integrity. */          /* check AH/ESP integrity. */
         if (so != NULL && ipsec6_in_reject_so(m, so)) {          if (so != NULL && ipsec6_in_reject_so(m, so)) {
                 ipsec6stat.in_polvio++;                  ipsec6stat.in_polvio++;
                   if ((n = m_copy(m, 0, M_COPYALL)) != NULL)
                           icmp6_error(n, ICMP6_DST_UNREACH,
                               ICMP6_DST_UNREACH_ADMIN, 0);
                 return;                  return;
         }          }
 #endif /*IPSEC*/  #endif /*IPSEC*/
Line 599  udp4_realinput(src, dst, m, off)
Line 588  udp4_realinput(src, dst, m, off)
         u_int16_t *sport, *dport;          u_int16_t *sport, *dport;
         int rcvcnt;          int rcvcnt;
         struct in_addr *src4, *dst4;          struct in_addr *src4, *dst4;
           struct inpcb_hdr *inph;
         struct inpcb *inp;          struct inpcb *inp;
   
         rcvcnt = 0;          rcvcnt = 0;
Line 614  udp4_realinput(src, dst, m, off)
Line 604  udp4_realinput(src, dst, m, off)
   
         if (IN_MULTICAST(dst4->s_addr) ||          if (IN_MULTICAST(dst4->s_addr) ||
             in_broadcast(*dst4, m->m_pkthdr.rcvif)) {              in_broadcast(*dst4, m->m_pkthdr.rcvif)) {
                 struct inpcb *last;  
                 /*                  /*
                  * Deliver a multicast or broadcast datagram to *all* sockets                   * Deliver a multicast or broadcast datagram to *all* sockets
                  * for which the local and remote addresses and ports match                   * for which the local and remote addresses and ports match
Line 632  udp4_realinput(src, dst, m, off)
Line 621  udp4_realinput(src, dst, m, off)
                  */                   */
   
                 /*                  /*
                  * KAME note: usually we drop udpiphdr from mbuf here.                   * KAME note: traditionally we dropped 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.
                  */                   */
                 for (inp = udbtable.inpt_queue.cqh_first;                  CIRCLEQ_FOREACH(inph, &udbtable.inpt_queue, inph_queue) {
                     inp != (struct inpcb *)&udbtable.inpt_queue;                          inp = (struct inpcb *)inph;
                     inp = inp->inp_queue.cqe_next) {                          if (inp->inp_af != AF_INET)
                                   continue;
   
                         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 653  udp4_realinput(src, dst, m, off)
Line 644  udp4_realinput(src, dst, m, off)
                                         continue;                                          continue;
                         }                          }
   
                         last = inp;  
                         udp4_sendup(m, off, (struct sockaddr *)src,                          udp4_sendup(m, off, (struct sockaddr *)src,
                                 inp->inp_socket);                                  inp->inp_socket);
                         rcvcnt++;                          rcvcnt++;
Line 693  bad:
Line 683  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 727  udp6_realinput(af, src, dst, m, off)
Line 694  udp6_realinput(af, src, dst, m, off)
         int rcvcnt;          int rcvcnt;
         struct in6_addr src6, dst6;          struct in6_addr src6, dst6;
         const struct in_addr *dst4;          const struct in_addr *dst4;
           struct inpcb_hdr *inph;
         struct in6pcb *in6p;          struct in6pcb *in6p;
   
         rcvcnt = 0;          rcvcnt = 0;
Line 741  udp6_realinput(af, src, dst, m, off)
Line 709  udp6_realinput(af, src, dst, m, off)
         sport = src->sin6_port;          sport = src->sin6_port;
         in6_embedscope(&dst6, dst, NULL, NULL);          in6_embedscope(&dst6, dst, NULL, NULL);
         dport = dst->sin6_port;          dport = dst->sin6_port;
         dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr32[12];          dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[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;  
                 /*                  /*
                  * Deliver a multicast or broadcast datagram to *all* sockets                   * Deliver a multicast or broadcast datagram to *all* sockets
                  * for which the local and remote addresses and ports match                   * for which the local and remote addresses and ports match
Line 763  udp6_realinput(af, src, dst, m, off)
Line 730  udp6_realinput(af, src, dst, m, off)
                  */                   */
   
                 /*                  /*
                  * KAME note: usually we drop udpiphdr from mbuf here.                   * KAME note: traditionally we dropped 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.
                  */                   */
                 for (in6p = udb6.in6p_next; in6p != &udb6;                  CIRCLEQ_FOREACH(inph, &udbtable.inpt_queue, inph_queue) {
                      in6p = in6p->in6p_next) {                          in6p = (struct in6pcb *)inph;
                           if (in6p->in6p_af != AF_INET6)
                                   continue;
   
                         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 {
 #ifndef INET6_BINDV6ONLY  
                         else {  
                                 if (IN6_IS_ADDR_V4MAPPED(&dst6) &&                                  if (IN6_IS_ADDR_V4MAPPED(&dst6) &&
                                     (in6p->in6p_flags & IN6P_BINDV6ONLY))                                      (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
                                         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) || in6p->in6p_fport != sport)                                      &src6) || in6p->in6p_fport != sport)
                                         continue;                                          continue;
                         }                          } else {
 #ifndef INET6_BINDV6ONLY  
                         else {  
                                 if (IN6_IS_ADDR_V4MAPPED(&src6) &&                                  if (IN6_IS_ADDR_V4MAPPED(&src6) &&
                                     (in6p->in6p_flags & IN6P_BINDV6ONLY))                                      (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
                                         continue;                                          continue;
                         }                          }
 #endif  
   
                         last = in6p;  
                         udp6_sendup(m, off, (struct sockaddr *)src,                          udp6_sendup(m, off, (struct sockaddr *)src,
                                 in6p->in6p_socket);                                  in6p->in6p_socket);
                         rcvcnt++;                          rcvcnt++;
Line 819  udp6_realinput(af, src, dst, m, off)
Line 781  udp6_realinput(af, src, dst, m, off)
                 /*                  /*
                  * Locate pcb for datagram.                   * Locate pcb for datagram.
                  */                   */
                 in6p = in6_pcblookup_connect(&udb6, &src6, sport,                  in6p = in6_pcblookup_connect(&udbtable, &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(&udbtable, &dst6, dport, 0);
                         if (in6p == 0)                          if (in6p == 0)
                                 return rcvcnt;                                  return rcvcnt;
                 }                  }
Line 837  bad:
Line 799  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) {  
                 switch (m->m_pkthdr.csum_flags &  
                         ((m->m_pkthdr.rcvif->if_csum_flags & M_CSUM_UDPv4) |  
                          M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {  
                 case M_CSUM_UDPv4|M_CSUM_TCP_UDP_BAD:  
                         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);  
                         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)  
                                 goto badcsum;  
                         break;  
                 }  
         }  
   
         /*  
          * 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);  
                                                 udpstat.udps_fullsock++;  
                                         } 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);  
         return;  
   
 badcsum:  
         udpstat.udps_badsum++;  
         m_freem(m);  
 }  
 #endif /*UDP6*/  
   
 #ifdef INET  #ifdef INET
 /*  /*
  * Notify a udp user of an asynchronous error;   * Notify a udp user of an asynchronous error;
Line 1206  udp_output(m, va_alist)
Line 865  udp_output(m, va_alist)
         int error = 0;          int error = 0;
         va_list ap;          va_list ap;
   
           MCLAIM(m, &udp_tx_mowner);
         va_start(ap, m);          va_start(ap, m);
         inp = va_arg(ap, struct inpcb *);          inp = va_arg(ap, struct inpcb *);
         va_end(ap);          va_end(ap);
Line 1224  udp_output(m, va_alist)
Line 884  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 1256  udp_output(m, va_alist)
Line 916  udp_output(m, va_alist)
                 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);                  m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
         } else          } else
                 ui->ui_sum = 0;                  ui->ui_sum = 0;
         ((struct ip *)ui)->ip_len = 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.udps_opackets++;          udpstat.udps_opackets++;
   
 #ifdef IPSEC  
         if (ipsec_setsocket(m, inp->inp_socket) != 0) {  
                 error = ENOBUFS;  
                 goto release;  
         }  
 #endif /*IPSEC*/  
   
         return (ip_output(m, inp->inp_options, &inp->inp_route,          return (ip_output(m, inp->inp_options, &inp->inp_route,
             inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST),              inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST),
             inp->inp_moptions));              inp->inp_moptions, inp->inp_socket));
   
 release:  release:
         m_freem(m);          m_freem(m);
Line 1326  udp_usrreq(so, req, m, nam, control, p)
Line 979  udp_usrreq(so, req, m, nam, control, p)
                         error = EISCONN;                          error = EISCONN;
                         break;                          break;
                 }                  }
   #ifdef MBUFTRACE
                   so->so_mowner = &udp_mowner;
                   so->so_rcv.sb_mowner = &udp_rx_mowner;
                   so->so_snd.sb_mowner = &udp_tx_mowner;
   #endif
                 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {                  if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
                         error = soreserve(so, udp_sendspace, udp_recvspace);                          error = soreserve(so, udp_sendspace, udp_recvspace);
                         if (error)                          if (error)
Line 1394  udp_usrreq(so, req, m, nam, control, p)
Line 1052  udp_usrreq(so, req, m, nam, control, p)
                                 goto die;                                  goto die;
                         }                          }
                         error = in_pcbconnect(inp, nam);                          error = in_pcbconnect(inp, nam);
                         if (error) {                          if (error)
                         die:                                  goto die;
                                 m_freem(m);  
                                 break;  
                         }  
                 } else {                  } else {
                         if ((so->so_state & SS_ISCONNECTED) == 0) {                          if ((so->so_state & SS_ISCONNECTED) == 0) {
                                 error = ENOTCONN;                                  error = ENOTCONN;
Line 1406  udp_usrreq(so, req, m, nam, control, p)
Line 1061  udp_usrreq(so, req, m, nam, control, p)
                         }                          }
                 }                  }
                 error = udp_output(m, inp);                  error = udp_output(m, inp);
                   m = NULL;
                 if (nam) {                  if (nam) {
                         in_pcbdisconnect(inp);                          in_pcbdisconnect(inp);
                         inp->inp_laddr = laddr;         /* XXX */                          inp->inp_laddr = laddr;         /* XXX */
                         in_pcbstate(inp, INP_BOUND);    /* XXX */                          in_pcbstate(inp, INP_BOUND);    /* XXX */
                 }                  }
             die:
                   if (m)
                           m_freem(m);
         }          }
                 break;                  break;
   
Line 1471  udp_sysctl(name, namelen, oldp, oldlenp,
Line 1130  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.84  
changed lines
  Added in v.1.113

CVSweb <webmaster@jp.NetBSD.org>