[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.5 and 1.78

version 1.75.2.5, 2001/11/14 19:17:59 version 1.78, 2001/06/02 16:17:11
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 83  __KERNEL_RCSID(0, "$NetBSD$");
Line 80  __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 148  static int udp4_realinput __P((struct so
Line 147  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 196  udp_init()
Line 197  udp_init()
 #endif /* UDP_CSUM_COUNTERS */  #endif /* UDP_CSUM_COUNTERS */
 }  }
   
   #ifndef UDP6
 #ifdef INET  #ifdef INET
 void  void
 #if __STDC__  #if __STDC__
Line 282  udp_input(m, va_alist)
Line 284  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 & 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);
Line 534  udp4_sendup(m, off, src, so)
Line 536  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 636  udp4_realinput(src, dst, m, off)
Line 637  udp4_realinput(src, dst, m, off)
                 /*                  /*
                  * 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 666  udp4_realinput(src, dst, m, off)
Line 669  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 674  udp4_realinput(src, dst, m, off)
Line 689  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 689  bad:
Line 728  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 696  udp6_realinput(af, src, dst, m, off)
Line 758  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 710  udp6_realinput(af, src, dst, m, off)
Line 772  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 744  udp6_realinput(af, src, dst, m, off)
Line 806  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;
                         }                          }
   #ifndef INET6_BINDV6ONLY
                         else {                          else {
                                 if (IN6_IS_ADDR_V4MAPPED(&dst6) &&                                  if (IN6_IS_ADDR_V4MAPPED(dst6)
                                     (in6p->in6p_flags & IN6P_IPV6_V6ONLY))                                   && (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;
                         }                          }
   #ifndef INET6_BINDV6ONLY
                         else {                          else {
                                 if (IN6_IS_ADDR_V4MAPPED(&src6) &&                                  if (IN6_IS_ADDR_V4MAPPED(src6)
                                     (in6p->in6p_flags & IN6P_IPV6_V6ONLY))                                   && (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 783  udp6_realinput(af, src, dst, m, off)
Line 850  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 805  bad:
Line 919  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);
                                           } 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 963  udp_usrreq(so, req, m, nam, control, p)
Line 1379  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 1001  udp_usrreq(so, req, m, nam, control, p)
Line 1416  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:

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

CVSweb <webmaster@jp.NetBSD.org>