[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.4 and 1.75.2.5

version 1.75.2.4, 2001/10/22 20:41:58 version 1.75.2.5, 2001/11/14 19:17:59
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_inet.h"
 #include "opt_ipsec.h"  #include "opt_ipsec.h"
 #include "opt_inet_csum.h"  #include "opt_inet_csum.h"
Line 80 
Line 83 
 #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 147  static int udp4_realinput __P((struct so
Line 148  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 197  udp_init()
Line 196  udp_init()
 #endif /* UDP_CSUM_COUNTERS */  #endif /* UDP_CSUM_COUNTERS */
 }  }
   
 #ifndef UDP6  
 #ifdef INET  #ifdef INET
 void  void
 #if __STDC__  #if __STDC__
Line 638  udp4_realinput(src, dst, m, off)
Line 636  udp4_realinput(src, dst, m, off)
                 /*                  /*
                  * Locate pcb(s) for datagram.                   * Locate pcb(s) for datagram.
                  */                   */
                 for (inp = udbtable.inpt_queue.cqh_first;                  CIRCLEQ_FOREACH(inp, &udbtable.inpt_queue, inp_queue) {
                     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 693  bad:
Line 689  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 741  udp6_realinput(af, src, dst, m, off)
Line 714  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))) {
Line 774  udp6_realinput(af, src, dst, m, off)
Line 747  udp6_realinput(af, src, dst, m, off)
                         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 {                          else {
Line 833  bad:
Line 805  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;

Legend:
Removed from v.1.75.2.4  
changed lines
  Added in v.1.75.2.5

CVSweb <webmaster@jp.NetBSD.org>