[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.194.2.1 and 1.195

version 1.194.2.1, 2014/08/10 06:56:25 version 1.195, 2014/05/18 14:46:16
Line 60 
Line 60 
  *      @(#)udp_usrreq.c        8.6 (Berkeley) 5/23/95   *      @(#)udp_usrreq.c        8.6 (Berkeley) 5/23/95
  */   */
   
 /*  
  * UDP protocol implementation.  
  * Per RFC 768, August, 1980.  
  */  
   
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
Line 76  __KERNEL_RCSID(0, "$NetBSD$");
Line 71  __KERNEL_RCSID(0, "$NetBSD$");
 #include "opt_mbuftrace.h"  #include "opt_mbuftrace.h"
   
 #include <sys/param.h>  #include <sys/param.h>
   #include <sys/malloc.h>
 #include <sys/mbuf.h>  #include <sys/mbuf.h>
 #include <sys/once.h>  #include <sys/once.h>
 #include <sys/protosw.h>  #include <sys/protosw.h>
 #include <sys/socket.h>  #include <sys/socket.h>
 #include <sys/socketvar.h>  #include <sys/socketvar.h>
   #include <sys/errno.h>
   #include <sys/stat.h>
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/domain.h>  #include <sys/domain.h>
Line 108  __KERNEL_RCSID(0, "$NetBSD$");
Line 106  __KERNEL_RCSID(0, "$NetBSD$");
 #include <netinet6/in6_pcb.h>  #include <netinet6/in6_pcb.h>
 #include <netinet6/udp6_var.h>  #include <netinet6/udp6_var.h>
 #include <netinet6/udp6_private.h>  #include <netinet6/udp6_private.h>
   #include <netinet6/scope6_var.h>
 #endif  #endif
   
 #ifndef INET6  #ifndef INET6
Line 115  __KERNEL_RCSID(0, "$NetBSD$");
Line 114  __KERNEL_RCSID(0, "$NetBSD$");
 #include <netinet/ip6.h>  #include <netinet/ip6.h>
 #endif  #endif
   
   #include "faith.h"
   #if defined(NFAITH) && NFAITH > 0
   #include <net/if_faith.h>
   #endif
   
 #ifdef IPSEC  #ifdef IPSEC
 #include <netipsec/ipsec.h>  #include <netipsec/ipsec.h>
 #include <netipsec/ipsec_var.h>  #include <netipsec/ipsec_var.h>
Line 133  __KERNEL_RCSID(0, "$NetBSD$");
Line 137  __KERNEL_RCSID(0, "$NetBSD$");
 #include <ipkdb/ipkdb.h>  #include <ipkdb/ipkdb.h>
 #endif  #endif
   
   /*
    * UDP protocol implementation.
    * Per RFC 768, August, 1980.
    */
 int     udpcksum = 1;  int     udpcksum = 1;
 int     udp_do_loopback_cksum = 0;  int     udp_do_loopback_cksum = 0;
   
Line 151  static int udp4_realinput (struct sockad
Line 159  static int udp4_realinput (struct sockad
         struct mbuf **, int);          struct mbuf **, int);
 static int udp4_input_checksum(struct mbuf *, const struct udphdr *, int, int);  static int udp4_input_checksum(struct mbuf *, const struct udphdr *, int, int);
 #endif  #endif
   #ifdef INET6
   static void udp6_sendup (struct mbuf *, int, struct sockaddr *,
           struct socket *);
   static int udp6_realinput (int, struct sockaddr_in6 *,
           struct sockaddr_in6 *, struct mbuf *, int);
   static int udp6_input_checksum(struct mbuf *, const struct udphdr *, int, int);
   #endif
 #ifdef INET  #ifdef INET
 static  void udp_notify (struct inpcb *, int);  static  void udp_notify (struct inpcb *, int);
 #endif  #endif
Line 160  static void udp_notify (struct inpcb *, 
Line 175  static void udp_notify (struct inpcb *, 
 #endif  #endif
 int     udbhashsize = UDBHASHSIZE;  int     udbhashsize = UDBHASHSIZE;
   
 /*  
  * For send - really max datagram size; for receive - 40 1K datagrams.  
  */  
 static int      udp_sendspace = 9216;  
 static int      udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));  
   
 #ifdef MBUFTRACE  #ifdef MBUFTRACE
 struct mowner udp_mowner = MOWNER_INIT("udp", "");  struct mowner udp_mowner = MOWNER_INIT("udp", "");
 struct mowner udp_rx_mowner = MOWNER_INIT("udp", "rx");  struct mowner udp_rx_mowner = MOWNER_INIT("udp", "rx");
Line 191  EVCNT_ATTACH_STATIC(udp_hwcsum_data);
Line 200  EVCNT_ATTACH_STATIC(udp_hwcsum_data);
 EVCNT_ATTACH_STATIC(udp_swcsum);  EVCNT_ATTACH_STATIC(udp_swcsum);
 #endif /* defined(INET) */  #endif /* defined(INET) */
   
   #if defined(INET6)
   struct evcnt udp6_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
       NULL, "udp6", "hwcsum bad");
   struct evcnt udp6_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
       NULL, "udp6", "hwcsum ok");
   struct evcnt udp6_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
       NULL, "udp6", "hwcsum data");
   struct evcnt udp6_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
       NULL, "udp6", "swcsum");
   
   EVCNT_ATTACH_STATIC(udp6_hwcsum_bad);
   EVCNT_ATTACH_STATIC(udp6_hwcsum_ok);
   EVCNT_ATTACH_STATIC(udp6_hwcsum_data);
   EVCNT_ATTACH_STATIC(udp6_swcsum);
   #endif /* defined(INET6) */
   
 #define UDP_CSUM_COUNTER_INCR(ev)       (ev)->ev_count++  #define UDP_CSUM_COUNTER_INCR(ev)       (ev)->ev_count++
   
 #else  #else
   
 #define UDP_CSUM_COUNTER_INCR(ev)       /* nothing */  #define UDP_CSUM_COUNTER_INCR(ev)       /* nothing */
   
 #endif /* UDP_CSUM_COUNTERS */  #endif /* UDP_CSUM_COUNTERS */
   
 static void sysctl_net_inet_udp_setup(struct sysctllog **);  static void sysctl_net_inet_udp_setup(struct sysctllog **);
Line 450  badcsum:
Line 478  badcsum:
 }  }
 #endif  #endif
   
   #ifdef INET6
   static int
   udp6_input_checksum(struct mbuf *m, const struct udphdr *uh, int off, int len)
   {
   
           /*
            * XXX it's better to record and check if this mbuf is
            * already checked.
            */
   
           if (__predict_false((m->m_flags & M_LOOP) && !udp_do_loopback_cksum)) {
                   goto good;
           }
           if (uh->uh_sum == 0) {
                   UDP6_STATINC(UDP6_STAT_NOSUM);
                   goto bad;
           }
   
           switch (m->m_pkthdr.csum_flags &
               ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv6) |
               M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
           case M_CSUM_UDPv6|M_CSUM_TCP_UDP_BAD:
                   UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_bad);
                   UDP6_STATINC(UDP6_STAT_BADSUM);
                   goto bad;
   
   #if 0 /* notyet */
           case M_CSUM_UDPv6|M_CSUM_DATA:
   #endif
   
           case M_CSUM_UDPv6:
                   /* Checksum was okay. */
                   UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_ok);
                   break;
   
           default:
                   /*
                    * Need to compute it ourselves.  Maybe skip checksum
                    * on loopback interfaces.
                    */
                   UDP_CSUM_COUNTER_INCR(&udp6_swcsum);
                   if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {
                           UDP6_STATINC(UDP6_STAT_BADSUM);
                           goto bad;
                   }
           }
   
   good:
           return 0;
   bad:
           return -1;
   }
   
   int
   udp6_input(struct mbuf **mp, int *offp, int proto)
   {
           struct mbuf *m = *mp;
           int off = *offp;
           struct sockaddr_in6 src, dst;
           struct ip6_hdr *ip6;
           struct udphdr *uh;
           u_int32_t plen, ulen;
   
           ip6 = mtod(m, struct ip6_hdr *);
   
   #if defined(NFAITH) && 0 < NFAITH
           if (faithprefix(&ip6->ip6_dst)) {
                   /* send icmp6 host unreach? */
                   m_freem(m);
                   return IPPROTO_DONE;
           }
   #endif
   
           UDP6_STATINC(UDP6_STAT_IPACKETS);
   
           /* check for jumbogram is done in ip6_input.  we can trust pkthdr.len */
           plen = m->m_pkthdr.len - off;
           IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));
           if (uh == NULL) {
                   IP6_STATINC(IP6_STAT_TOOSHORT);
                   return IPPROTO_DONE;
           }
           KASSERT(UDP_HDR_ALIGNED_P(uh));
           ulen = ntohs((u_short)uh->uh_ulen);
           /*
            * RFC2675 section 4: jumbograms will have 0 in the UDP header field,
            * iff payload length > 0xffff.
            */
           if (ulen == 0 && plen > 0xffff)
                   ulen = plen;
   
           if (plen != ulen) {
                   UDP6_STATINC(UDP6_STAT_BADLEN);
                   goto bad;
           }
   
           /* destination port of 0 is illegal, based on RFC768. */
           if (uh->uh_dport == 0)
                   goto bad;
   
           /* Be proactive about malicious use of IPv4 mapped address */
           if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
               IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
                   /* XXX stat */
                   goto bad;
           }
   
           /*
            * Checksum extended UDP header and data.  Maybe skip checksum
            * on loopback interfaces.
            */
           if (udp6_input_checksum(m, uh, off, ulen))
                   goto bad;
   
           /*
            * Construct source and dst sockaddrs.
            */
           memset(&src, 0, sizeof(src));
           src.sin6_family = AF_INET6;
           src.sin6_len = sizeof(struct sockaddr_in6);
           src.sin6_addr = ip6->ip6_src;
           src.sin6_port = uh->uh_sport;
           memset(&dst, 0, sizeof(dst));
           dst.sin6_family = AF_INET6;
           dst.sin6_len = sizeof(struct sockaddr_in6);
           dst.sin6_addr = ip6->ip6_dst;
           dst.sin6_port = uh->uh_dport;
   
           if (udp6_realinput(AF_INET6, &src, &dst, m, off) == 0) {
                   if (m->m_flags & M_MCAST) {
                           UDP6_STATINC(UDP6_STAT_NOPORTMCAST);
                           goto bad;
                   }
                   UDP6_STATINC(UDP6_STAT_NOPORT);
                   icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
                   m = NULL;
           }
   
   bad:
           if (m)
                   m_freem(m);
           return IPPROTO_DONE;
   }
   #endif
   
 #ifdef INET  #ifdef INET
 static void  static void
 udp4_sendup(struct mbuf *m, int off /* offset of data portion */,  udp4_sendup(struct mbuf *m, int off /* offset of data portion */,
Line 475  udp4_sendup(struct mbuf *m, int off /* o
Line 648  udp4_sendup(struct mbuf *m, int off /* o
   
 #if defined(IPSEC)  #if defined(IPSEC)
         /* check AH/ESP integrity. */          /* check AH/ESP integrity. */
         if (ipsec_used && so != NULL && ipsec4_in_reject_so(m, so)) {          if (so != NULL && ipsec4_in_reject_so(m, so)) {
                 IPSEC_STATINC(IPSEC_STAT_IN_POLVIO);                  IPSEC_STATINC(IPSEC_STAT_IN_POLVIO);
                 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)                  if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
                         icmp_error(n, ICMP_UNREACH, ICMP_UNREACH_ADMIN_PROHIBIT,                          icmp_error(n, ICMP_UNREACH, ICMP_UNREACH_ADMIN_PROHIBIT,
Line 508  udp4_sendup(struct mbuf *m, int off /* o
Line 681  udp4_sendup(struct mbuf *m, int off /* o
 }  }
 #endif  #endif
   
   #ifdef INET6
   static void
   udp6_sendup(struct mbuf *m, int off /* offset of data portion */,
           struct sockaddr *src, struct socket *so)
   {
           struct mbuf *opts = NULL;
           struct mbuf *n;
           struct in6pcb *in6p = NULL;
   
           if (!so)
                   return;
           if (so->so_proto->pr_domain->dom_family != AF_INET6)
                   return;
           in6p = sotoin6pcb(so);
   
   #if defined(IPSEC)
           /* check AH/ESP integrity. */
           if (so != NULL && ipsec6_in_reject_so(m, so)) {
                   IPSEC6_STATINC(IPSEC_STAT_IN_POLVIO);
                   if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
                           icmp6_error(n, ICMP6_DST_UNREACH,
                               ICMP6_DST_UNREACH_ADMIN, 0);
                   return;
           }
   #endif /*IPSEC*/
   
           if ((n = m_copypacket(m, M_DONTWAIT)) != NULL) {
                   if (in6p && (in6p->in6p_flags & IN6P_CONTROLOPTS
   #ifdef SO_OTIMESTAMP
                       || in6p->in6p_socket->so_options & SO_OTIMESTAMP
   #endif
                       || in6p->in6p_socket->so_options & SO_TIMESTAMP)) {
                           struct ip6_hdr *ip6 = mtod(n, struct ip6_hdr *);
                           ip6_savecontrol(in6p, &opts, ip6, n);
                   }
   
                   m_adj(n, off);
                   if (sbappendaddr(&so->so_rcv, src, n, opts) == 0) {
                           m_freem(n);
                           if (opts)
                                   m_freem(opts);
                           so->so_rcv.sb_overflowed++;
                           UDP6_STATINC(UDP6_STAT_FULLSOCK);
                   } else
                           sorwakeup(so);
           }
   }
   #endif
   
 #ifdef INET  #ifdef INET
 static int  static int
 udp4_realinput(struct sockaddr_in *src, struct sockaddr_in *dst,  udp4_realinput(struct sockaddr_in *src, struct sockaddr_in *dst,
Line 645  bad:
Line 867  bad:
 }  }
 #endif  #endif
   
   #ifdef INET6
   static int
   udp6_realinput(int af, struct sockaddr_in6 *src, struct sockaddr_in6 *dst,
           struct mbuf *m, int off)
   {
           u_int16_t sport, dport;
           int rcvcnt;
           struct in6_addr src6, *dst6;
           const struct in_addr *dst4;
           struct inpcb_hdr *inph;
           struct in6pcb *in6p;
   
           rcvcnt = 0;
           off += sizeof(struct udphdr);   /* now, offset of payload */
   
           if (af != AF_INET && af != AF_INET6)
                   goto bad;
           if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)
                   goto bad;
   
           src6 = src->sin6_addr;
           if (sa6_recoverscope(src) != 0) {
                   /* XXX: should be impossible. */
                   goto bad;
           }
           sport = src->sin6_port;
   
           dport = dst->sin6_port;
           dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[12];
           dst6 = &dst->sin6_addr;
   
           if (IN6_IS_ADDR_MULTICAST(dst6) ||
               (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {
                   /*
                    * 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?)
                    */
   
                   /*
                    * KAME note: traditionally we dropped udpiphdr from mbuf here.
                    * we need udpiphdr for IPsec processing so we do that later.
                    */
                   /*
                    * Locate pcb(s) for datagram.
                    */
                   TAILQ_FOREACH(inph, &udbtable.inpt_queue, inph_queue) {
                           in6p = (struct in6pcb *)inph;
                           if (in6p->in6p_af != AF_INET6)
                                   continue;
   
                           if (in6p->in6p_lport != dport)
                                   continue;
                           if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {
                                   if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr,
                                       dst6))
                                           continue;
                           } else {
                                   if (IN6_IS_ADDR_V4MAPPED(dst6) &&
                                       (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
                                           continue;
                           }
                           if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
                                   if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr,
                                       &src6) || in6p->in6p_fport != sport)
                                           continue;
                           } else {
                                   if (IN6_IS_ADDR_V4MAPPED(&src6) &&
                                       (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
                                           continue;
                           }
   
                           udp6_sendup(m, off, (struct sockaddr *)src,
                                   in6p->in6p_socket);
                           rcvcnt++;
   
                           /*
                            * 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 ((in6p->in6p_socket->so_options &
                               (SO_REUSEPORT|SO_REUSEADDR)) == 0)
                                   break;
                   }
           } else {
                   /*
                    * Locate pcb for datagram.
                    */
                   in6p = in6_pcblookup_connect(&udbtable, &src6, sport, dst6,
                                                dport, 0, 0);
                   if (in6p == 0) {
                           UDP_STATINC(UDP_STAT_PCBHASHMISS);
                           in6p = in6_pcblookup_bind(&udbtable, dst6, dport, 0);
                           if (in6p == 0)
                                   return rcvcnt;
                   }
   
                   udp6_sendup(m, off, (struct sockaddr *)src, in6p->in6p_socket);
                   rcvcnt++;
           }
   
   bad:
           return rcvcnt;
   }
   #endif
   
 #ifdef INET  #ifdef INET
 /*  /*
  * Notify a udp user of an asynchronous error;   * Notify a udp user of an asynchronous error;
Line 849  release:
Line 1191  release:
         return (error);          return (error);
 }  }
   
 static int  int     udp_sendspace = 9216;           /* really max datagram size */
 udp_attach(struct socket *so, int proto)  int     udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
 {                                          /* 40 1K datagrams */
         struct inpcb *inp;  
         int error;  
   
         KASSERT(sotoinpcb(so) == NULL);  
   
         /* Assign the lock (must happen even if we will error out). */  
         sosetlock(so);  
   
 #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) {  
                 error = soreserve(so, udp_sendspace, udp_recvspace);  
                 if (error) {  
                         return error;  
                 }  
         }  
   
         error = in_pcballoc(so, &udbtable);  
         if (error) {  
                 return error;  
         }  
         inp = sotoinpcb(so);  
         inp->inp_ip.ip_ttl = ip_defttl;  
         KASSERT(solocked(so));  
   
         return error;  
 }  
   
 static void  
 udp_detach(struct socket *so)  
 {  
         struct inpcb *inp;  
   
         KASSERT(solocked(so));  
         inp = sotoinpcb(so);  
         KASSERT(inp != NULL);  
         in_pcbdetach(inp);  
 }  
   
 static int  
 udp_accept(struct socket *so, struct mbuf *nam)  
 {  
         KASSERT(solocked(so));  
   
         panic("udp_accept");  
   
         return EOPNOTSUPP;  
 }  
   
 static int  static int
 udp_bind(struct socket *so, struct mbuf *nam, struct lwp *l)  udp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
       struct mbuf *control, struct lwp *l)
 {  {
         struct inpcb *inp = sotoinpcb(so);          struct inpcb *inp;
         int error = 0;  
         int s;          int s;
   
         KASSERT(solocked(so));  
         KASSERT(inp != NULL);  
         KASSERT(nam != NULL);  
   
         s = splsoftnet();  
         error = in_pcbbind(inp, nam, l);  
         splx(s);  
   
         return error;  
 }  
   
 static int  
 udp_listen(struct socket *so, struct lwp *l)  
 {  
         KASSERT(solocked(so));  
   
         return EOPNOTSUPP;  
 }  
   
 static int  
 udp_connect(struct socket *so, struct mbuf *nam, struct lwp *l)  
 {  
         struct inpcb *inp = sotoinpcb(so);  
         int error = 0;          int error = 0;
         int s;  
   
         KASSERT(solocked(so));  
         KASSERT(inp != NULL);  
         KASSERT(nam != NULL);  
   
         s = splsoftnet();  
         error = in_pcbconnect(inp, nam, l);  
         if (! error)  
                 soisconnected(so);  
         splx(s);  
         return error;  
 }  
   
 static int  
 udp_connect2(struct socket *so, struct socket *so2)  
 {  
         KASSERT(solocked(so));  
   
         return EOPNOTSUPP;  
 }  
   
 static int  
 udp_disconnect(struct socket *so)  
 {  
         struct inpcb *inp = sotoinpcb(so);  
         int s;  
   
         KASSERT(solocked(so));  
         KASSERT(inp != NULL);  
   
         s = splsoftnet();  
         /*soisdisconnected(so);*/  
         so->so_state &= ~SS_ISCONNECTED;        /* XXX */  
         in_pcbdisconnect(inp);  
         inp->inp_laddr = zeroin_addr;           /* XXX */  
         in_pcbstate(inp, INP_BOUND);            /* XXX */  
         splx(s);  
   
         return 0;  
 }  
   
 static int  
 udp_shutdown(struct socket *so)  
 {  
         int s;  
   
         KASSERT(solocked(so));  
   
         s = splsoftnet();  
         socantsendmore(so);  
         splx(s);  
   
         return 0;  
 }  
   
 static int  
 udp_abort(struct socket *so)  
 {  
         KASSERT(solocked(so));  
   
         panic("udp_abort");  
   
         return EOPNOTSUPP;  
 }  
   
 static int          if (req == PRU_CONTROL)
 udp_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp)                  return (in_control(so, (long)m, (void *)nam,
 {                      (struct ifnet *)control, l));
         return in_control(so, cmd, nam, ifp);  
 }  
   
 static int  
 udp_stat(struct socket *so, struct stat *ub)  
 {  
         KASSERT(solocked(so));  
   
         /* stat: don't bother with a blocksize. */  
         return 0;  
 }  
   
 static int  
 udp_peeraddr(struct socket *so, struct mbuf *nam)  
 {  
         int s;  
   
         KASSERT(solocked(so));  
         KASSERT(sotoinpcb(so) != NULL);  
         KASSERT(nam != NULL);  
   
         s = splsoftnet();          s = splsoftnet();
         in_setpeeraddr(sotoinpcb(so), nam);  
         splx(s);  
   
         return 0;          if (req == PRU_PURGEIF) {
 }                  mutex_enter(softnet_lock);
                   in_pcbpurgeif0(&udbtable, (struct ifnet *)control);
                   in_purgeif((struct ifnet *)control);
                   in_pcbpurgeif(&udbtable, (struct ifnet *)control);
                   mutex_exit(softnet_lock);
                   splx(s);
                   return (0);
           }
   
 static int          inp = sotoinpcb(so);
 udp_sockaddr(struct socket *so, struct mbuf *nam)  #ifdef DIAGNOSTIC
 {          if (req != PRU_SEND && req != PRU_SENDOOB && control)
         int s;                  panic("udp_usrreq: unexpected control mbuf");
   #endif
           if (req == PRU_ATTACH) {
                   sosetlock(so);
           } else if (inp == 0) {
                   error = EINVAL;
                   goto release;
           }
   
         KASSERT(solocked(so));          /*
         KASSERT(sotoinpcb(so) != NULL);           * Note: need to block udp_input while changing
         KASSERT(nam != NULL);           * the udp pcb queue and/or pcb addresses.
            */
           switch (req) {
   
         s = splsoftnet();          case PRU_ATTACH:
         in_setsockaddr(sotoinpcb(so), nam);                  if (inp != 0) {
         splx(s);                          error = EISCONN;
                           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) {
                           error = soreserve(so, udp_sendspace, udp_recvspace);
                           if (error)
                                   break;
                   }
                   error = in_pcballoc(so, &udbtable);
                   if (error)
                           break;
                   inp = sotoinpcb(so);
                   inp->inp_ip.ip_ttl = ip_defttl;
                   break;
   
         return 0;          case PRU_DETACH:
 }                  in_pcbdetach(inp);
                   break;
   
 static int          case PRU_BIND:
 udp_rcvd(struct socket *so, int flags, struct lwp *l)                  error = in_pcbbind(inp, nam, l);
 {                  break;
         KASSERT(solocked(so));  
   
         return EOPNOTSUPP;          case PRU_LISTEN:
 }                  error = EOPNOTSUPP;
                   break;
   
 static int          case PRU_CONNECT:
 udp_recvoob(struct socket *so, struct mbuf *m, int flags)                  error = in_pcbconnect(inp, nam, l);
 {                  if (error)
         KASSERT(solocked(so));                          break;
                   soisconnected(so);
                   break;
   
         return EOPNOTSUPP;          case PRU_CONNECT2:
 }                  error = EOPNOTSUPP;
                   break;
   
 static int          case PRU_DISCONNECT:
 udp_send(struct socket *so, struct mbuf *m, struct mbuf *nam,                  /*soisdisconnected(so);*/
     struct mbuf *control, struct lwp *l)                  so->so_state &= ~SS_ISCONNECTED;        /* XXX */
 {                  in_pcbdisconnect(inp);
         struct inpcb *inp = sotoinpcb(so);                  inp->inp_laddr = zeroin_addr;           /* XXX */
         int error = 0;                  in_pcbstate(inp, INP_BOUND);            /* XXX */
         struct in_addr laddr;                   /* XXX */                  break;
         int s;  
   
         KASSERT(solocked(so));          case PRU_SHUTDOWN:
         KASSERT(inp != NULL);                  socantsendmore(so);
         KASSERT(m != NULL);                  break;
   
         if (control && control->m_len) {          case PRU_RCVD:
                 m_freem(control);                  error = EOPNOTSUPP;
                 m_freem(m);                  break;
                 return EINVAL;  
         }  
   
         memset(&laddr, 0, sizeof laddr);          case PRU_SEND:
                   if (control && control->m_len) {
                           m_freem(control);
                           m_freem(m);
                           error = EINVAL;
                           break;
                   }
           {
                   struct in_addr laddr;                   /* XXX */
   
         s = splsoftnet();                  memset(&laddr, 0, sizeof laddr);
         if (nam) {                  if (nam) {
                 laddr = inp->inp_laddr;         /* XXX */                          laddr = inp->inp_laddr;         /* XXX */
                 if ((so->so_state & SS_ISCONNECTED) != 0) {                          if ((so->so_state & SS_ISCONNECTED) != 0) {
                         error = EISCONN;                                  error = EISCONN;
                         goto die;                                  goto die;
                           }
                           error = in_pcbconnect(inp, nam, l);
                           if (error)
                                   goto die;
                   } else {
                           if ((so->so_state & SS_ISCONNECTED) == 0) {
                                   error = ENOTCONN;
                                   goto die;
                           }
                 }                  }
                 error = in_pcbconnect(inp, nam, l);                  error = udp_output(m, inp);
                 if (error)                  m = NULL;
                         goto die;                  if (nam) {
         } else {                          in_pcbdisconnect(inp);
                 if ((so->so_state & SS_ISCONNECTED) == 0) {                          inp->inp_laddr = laddr;         /* XXX */
                         error = ENOTCONN;                          in_pcbstate(inp, INP_BOUND);    /* XXX */
                         goto die;  
                 }                  }
             die:
                   if (m)
                           m_freem(m);
         }          }
         error = udp_output(m, inp);                  break;
         m = NULL;  
         if (nam) {  
                 in_pcbdisconnect(inp);  
                 inp->inp_laddr = laddr;         /* XXX */  
                 in_pcbstate(inp, INP_BOUND);    /* XXX */  
         }  
   die:  
         if (m)  
                 m_freem(m);  
   
         splx(s);  
         return error;  
 }  
   
 static int  
 udp_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)  
 {  
         KASSERT(solocked(so));  
   
         m_freem(m);  
         m_freem(control);  
   
         return EOPNOTSUPP;  
 }  
   
 static int  
 udp_purgeif(struct socket *so, struct ifnet *ifp)  
 {  
         int s;  
   
         s = splsoftnet();          case PRU_SENSE:
         mutex_enter(softnet_lock);                  /*
         in_pcbpurgeif0(&udbtable, ifp);                   * stat: don't bother with a blocksize.
         in_purgeif(ifp);                   */
         in_pcbpurgeif(&udbtable, ifp);                  splx(s);
         mutex_exit(softnet_lock);                  return (0);
         splx(s);  
   
         return 0;          case PRU_RCVOOB:
 }                  error =  EOPNOTSUPP;
                   break;
   
 static int          case PRU_SENDOOB:
 udp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,                  m_freem(control);
     struct mbuf *control, struct lwp *l)                  m_freem(m);
 {                  error =  EOPNOTSUPP;
         KASSERT(req != PRU_ATTACH);                  break;
         KASSERT(req != PRU_DETACH);  
         KASSERT(req != PRU_ACCEPT);  
         KASSERT(req != PRU_BIND);  
         KASSERT(req != PRU_LISTEN);  
         KASSERT(req != PRU_CONNECT);  
         KASSERT(req != PRU_CONNECT2);  
         KASSERT(req != PRU_DISCONNECT);  
         KASSERT(req != PRU_SHUTDOWN);  
         KASSERT(req != PRU_ABORT);  
         KASSERT(req != PRU_CONTROL);  
         KASSERT(req != PRU_SENSE);  
         KASSERT(req != PRU_PEERADDR);  
         KASSERT(req != PRU_SOCKADDR);  
         KASSERT(req != PRU_RCVD);  
         KASSERT(req != PRU_RCVOOB);  
         KASSERT(req != PRU_SEND);  
         KASSERT(req != PRU_SENDOOB);  
         KASSERT(req != PRU_PURGEIF);  
   
         KASSERT(solocked(so));          case PRU_SOCKADDR:
                   in_setsockaddr(inp, nam);
                   break;
   
         if (sotoinpcb(so) == NULL)          case PRU_PEERADDR:
                 return EINVAL;                  in_setpeeraddr(inp, nam);
                   break;
   
         panic("udp_usrreq");          default:
                   panic("udp_usrreq");
           }
   
         return 0;  release:
           splx(s);
           return (error);
 }  }
   
 static int  static int
Line 1381  udp4_espinudp(struct mbuf **mp, int off,
Line 1575  udp4_espinudp(struct mbuf **mp, int off,
         m_tag_prepend(m, tag);          m_tag_prepend(m, tag);
   
 #ifdef IPSEC  #ifdef IPSEC
         if (ipsec_used)          ipsec4_common_input(m, iphdrlen, IPPROTO_ESP);
                 ipsec4_common_input(m, iphdrlen, IPPROTO_ESP);  
         /* XXX: else */  
 #else  #else
         esp4_input(m, iphdrlen);          esp4_input(m, iphdrlen);
 #endif  #endif
Line 1394  udp4_espinudp(struct mbuf **mp, int off,
Line 1586  udp4_espinudp(struct mbuf **mp, int off,
 }  }
 #endif  #endif
   
 PR_WRAP_USRREQS(udp)  PR_WRAP_USRREQ(udp_usrreq)
 #define udp_attach      udp_attach_wrapper  
 #define udp_detach      udp_detach_wrapper  
 #define udp_accept      udp_accept_wrapper  
 #define udp_bind        udp_bind_wrapper  
 #define udp_listen      udp_listen_wrapper  
 #define udp_connect     udp_connect_wrapper  
 #define udp_connect2    udp_connect2_wrapper  
 #define udp_disconnect  udp_disconnect_wrapper  
 #define udp_shutdown    udp_shutdown_wrapper  
 #define udp_abort       udp_abort_wrapper  
 #define udp_ioctl       udp_ioctl_wrapper  
 #define udp_stat        udp_stat_wrapper  
 #define udp_peeraddr    udp_peeraddr_wrapper  
 #define udp_sockaddr    udp_sockaddr_wrapper  
 #define udp_rcvd        udp_rcvd_wrapper  
 #define udp_recvoob     udp_recvoob_wrapper  
 #define udp_send        udp_send_wrapper  
 #define udp_sendoob     udp_sendoob_wrapper  
 #define udp_purgeif     udp_purgeif_wrapper  
 #define udp_usrreq      udp_usrreq_wrapper  #define udp_usrreq      udp_usrreq_wrapper
   
 const struct pr_usrreqs udp_usrreqs = {  const struct pr_usrreqs udp_usrreqs = {
         .pr_attach      = udp_attach,  
         .pr_detach      = udp_detach,  
         .pr_accept      = udp_accept,  
         .pr_bind        = udp_bind,  
         .pr_listen      = udp_listen,  
         .pr_connect     = udp_connect,  
         .pr_connect2    = udp_connect2,  
         .pr_disconnect  = udp_disconnect,  
         .pr_shutdown    = udp_shutdown,  
         .pr_abort       = udp_abort,  
         .pr_ioctl       = udp_ioctl,  
         .pr_stat        = udp_stat,  
         .pr_peeraddr    = udp_peeraddr,  
         .pr_sockaddr    = udp_sockaddr,  
         .pr_rcvd        = udp_rcvd,  
         .pr_recvoob     = udp_recvoob,  
         .pr_send        = udp_send,  
         .pr_sendoob     = udp_sendoob,  
         .pr_purgeif     = udp_purgeif,  
         .pr_generic     = udp_usrreq,          .pr_generic     = udp_usrreq,
 };  };

Legend:
Removed from v.1.194.2.1  
changed lines
  Added in v.1.195

CVSweb <webmaster@jp.NetBSD.org>