[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.217 and 1.217.4.5

version 1.217, 2014/08/09 05:33:01 version 1.217.4.5, 2016/05/29 08:44:38
Line 68 
Line 68 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
   #ifdef _KERNEL_OPT
 #include "opt_inet.h"  #include "opt_inet.h"
 #include "opt_compat_netbsd.h"  #include "opt_compat_netbsd.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 "opt_mbuftrace.h"
   #endif
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/mbuf.h>  #include <sys/mbuf.h>
Line 87  __KERNEL_RCSID(0, "$NetBSD$");
Line 89  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   
 #include <net/if.h>  #include <net/if.h>
 #include <net/route.h>  
   
 #include <netinet/in.h>  #include <netinet/in.h>
 #include <netinet/in_systm.h>  #include <netinet/in_systm.h>
Line 403  udp_input(struct mbuf *m, ...)
Line 404  udp_input(struct mbuf *m, ...)
                 memset(&src6, 0, sizeof(src6));                  memset(&src6, 0, sizeof(src6));
                 src6.sin6_family = AF_INET6;                  src6.sin6_family = AF_INET6;
                 src6.sin6_len = sizeof(struct sockaddr_in6);                  src6.sin6_len = sizeof(struct sockaddr_in6);
                 src6.sin6_addr.s6_addr[10] = src6.sin6_addr.s6_addr[11] = 0xff;                  in6_in_2_v4mapin6(&ip->ip_src, &src6.sin6_addr);
                 memcpy(&src6.sin6_addr.s6_addr[12], &ip->ip_src,  
                         sizeof(ip->ip_src));  
                 src6.sin6_port = uh->uh_sport;                  src6.sin6_port = uh->uh_sport;
                 memset(&dst6, 0, sizeof(dst6));                  memset(&dst6, 0, sizeof(dst6));
                 dst6.sin6_family = AF_INET6;                  dst6.sin6_family = AF_INET6;
                 dst6.sin6_len = sizeof(struct sockaddr_in6);                  dst6.sin6_len = sizeof(struct sockaddr_in6);
                 dst6.sin6_addr.s6_addr[10] = dst6.sin6_addr.s6_addr[11] = 0xff;                  in6_in_2_v4mapin6(&ip->ip_dst, &dst6.sin6_addr);
                 memcpy(&dst6.sin6_addr.s6_addr[12], &ip->ip_dst,  
                         sizeof(ip->ip_dst));  
                 dst6.sin6_port = uh->uh_dport;                  dst6.sin6_port = uh->uh_dport;
   
                 n += udp6_realinput(AF_INET, &src6, &dst6, m, iphlen);                  n += udp6_realinput(AF_INET, &src6, &dst6, m, iphlen);
Line 620  udp4_realinput(struct sockaddr_in *src, 
Line 617  udp4_realinput(struct sockaddr_in *src, 
   
                         case 0:         /* plain UDP */                          case 0:         /* plain UDP */
                         default:        /* Unexpected */                          default:        /* Unexpected */
                                 /*                                  /*
                                  * Normal UDP processing will take place                                   * Normal UDP processing will take place
                                  * m may have changed.                                   * m may have changed.
                                  */                                   */
                                 m = *mp;                                  m = *mp;
Line 754  udp_ctloutput(int op, struct socket *so,
Line 751  udp_ctloutput(int op, struct socket *so,
                                 break;                                  break;
                         }                          }
                         break;                          break;
   
                 default:                  default:
                         error = ENOPROTOOPT;                          error = ENOPROTOOPT;
                         break;                          break;
Line 773  end:
Line 770  end:
   
   
 int  int
 udp_output(struct mbuf *m, ...)  udp_output(struct mbuf *m, struct inpcb *inp)
 {  {
         struct inpcb *inp;  
         struct udpiphdr *ui;          struct udpiphdr *ui;
         struct route *ro;          struct route *ro;
         int len = m->m_pkthdr.len;          int len = m->m_pkthdr.len;
         int error = 0;          int error = 0;
         va_list ap;  
   
         MCLAIM(m, &udp_tx_mowner);          MCLAIM(m, &udp_tx_mowner);
         va_start(ap, m);  
         inp = va_arg(ap, struct inpcb *);  
         va_end(ap);  
   
         /*          /*
          * Calculate data length and get a mbuf           * Calculate data length and get a mbuf
Line 895  udp_detach(struct socket *so)
Line 887  udp_detach(struct socket *so)
 }  }
   
 static int  static int
 udp_accept(struct socket *so, struct mbuf *nam)  udp_accept(struct socket *so, struct sockaddr *nam)
 {  {
         KASSERT(solocked(so));          KASSERT(solocked(so));
   
Line 905  udp_accept(struct socket *so, struct mbu
Line 897  udp_accept(struct socket *so, struct mbu
 }  }
   
 static int  static int
 udp_bind(struct socket *so, struct mbuf *nam, struct lwp *l)  udp_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
 {  {
         struct inpcb *inp = sotoinpcb(so);          struct inpcb *inp = sotoinpcb(so);
           struct sockaddr_in *sin = (struct sockaddr_in *)nam;
         int error = 0;          int error = 0;
         int s;          int s;
   
Line 916  udp_bind(struct socket *so, struct mbuf 
Line 909  udp_bind(struct socket *so, struct mbuf 
         KASSERT(nam != NULL);          KASSERT(nam != NULL);
   
         s = splsoftnet();          s = splsoftnet();
         error = in_pcbbind(inp, nam, l);          error = in_pcbbind(inp, sin, l);
         splx(s);          splx(s);
   
         return error;          return error;
Line 931  udp_listen(struct socket *so, struct lwp
Line 924  udp_listen(struct socket *so, struct lwp
 }  }
   
 static int  static int
 udp_connect(struct socket *so, struct mbuf *nam, struct lwp *l)  udp_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
 {  {
         struct inpcb *inp = sotoinpcb(so);          struct inpcb *inp = sotoinpcb(so);
         int error = 0;          int error = 0;
Line 942  udp_connect(struct socket *so, struct mb
Line 935  udp_connect(struct socket *so, struct mb
         KASSERT(nam != NULL);          KASSERT(nam != NULL);
   
         s = splsoftnet();          s = splsoftnet();
         error = in_pcbconnect(inp, nam, l);          error = in_pcbconnect(inp, (struct sockaddr_in *)nam, l);
         if (! error)          if (! error)
                 soisconnected(so);                  soisconnected(so);
         splx(s);          splx(s);
Line 1017  udp_stat(struct socket *so, struct stat 
Line 1010  udp_stat(struct socket *so, struct stat 
 }  }
   
 static int  static int
 udp_peeraddr(struct socket *so, struct mbuf *nam)  udp_peeraddr(struct socket *so, struct sockaddr *nam)
 {  {
         int s;          int s;
   
Line 1026  udp_peeraddr(struct socket *so, struct m
Line 1019  udp_peeraddr(struct socket *so, struct m
         KASSERT(nam != NULL);          KASSERT(nam != NULL);
   
         s = splsoftnet();          s = splsoftnet();
         in_setpeeraddr(sotoinpcb(so), nam);          in_setpeeraddr(sotoinpcb(so), (struct sockaddr_in *)nam);
         splx(s);          splx(s);
   
         return 0;          return 0;
 }  }
   
 static int  static int
 udp_sockaddr(struct socket *so, struct mbuf *nam)  udp_sockaddr(struct socket *so, struct sockaddr *nam)
 {  {
         int s;          int s;
   
Line 1042  udp_sockaddr(struct socket *so, struct m
Line 1035  udp_sockaddr(struct socket *so, struct m
         KASSERT(nam != NULL);          KASSERT(nam != NULL);
   
         s = splsoftnet();          s = splsoftnet();
         in_setsockaddr(sotoinpcb(so), nam);          in_setsockaddr(sotoinpcb(so), (struct sockaddr_in *)nam);
         splx(s);          splx(s);
   
         return 0;          return 0;
Line 1065  udp_recvoob(struct socket *so, struct mb
Line 1058  udp_recvoob(struct socket *so, struct mb
 }  }
   
 static int  static int
 udp_send(struct socket *so, struct mbuf *m, struct mbuf *nam,  udp_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
     struct mbuf *control, struct lwp *l)      struct mbuf *control, struct lwp *l)
 {  {
         struct inpcb *inp = sotoinpcb(so);          struct inpcb *inp = sotoinpcb(so);
Line 1092  udp_send(struct socket *so, struct mbuf 
Line 1085  udp_send(struct socket *so, struct mbuf 
                         error = EISCONN;                          error = EISCONN;
                         goto die;                          goto die;
                 }                  }
                 error = in_pcbconnect(inp, nam, l);                  error = in_pcbconnect(inp, (struct sockaddr_in *)nam, l);
                 if (error)                  if (error)
                         goto die;                          goto die;
         } else {          } else {
Line 1144  udp_purgeif(struct socket *so, struct if
Line 1137  udp_purgeif(struct socket *so, struct if
 }  }
   
 static int  static int
 udp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,  
     struct mbuf *control, struct lwp *l)  
 {  
         KASSERT(req != PRU_ATTACH);  
         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));  
   
         if (sotoinpcb(so) == NULL)  
                 return EINVAL;  
   
         panic("udp_usrreq");  
   
         return 0;  
 }  
   
 static int  
 sysctl_net_inet_udp_stats(SYSCTLFN_ARGS)  sysctl_net_inet_udp_stats(SYSCTLFN_ARGS)
 {  {
   
Line 1331  udp4_espinudp(struct mbuf **mp, int off,
Line 1290  udp4_espinudp(struct mbuf **mp, int off,
         }          }
   
         /*          /*
          * Get the UDP ports. They are handled in network           * Get the UDP ports. They are handled in network
          * order everywhere in IPSEC_NAT_T code.           * order everywhere in IPSEC_NAT_T code.
          */           */
         udphdr = (struct udphdr *)((char *)data - skip);          udphdr = (struct udphdr *)((char *)data - skip);
Line 1363  udp4_espinudp(struct mbuf **mp, int off,
Line 1322  udp4_espinudp(struct mbuf **mp, int off,
   
         /*          /*
          * We have modified the packet - it is now ESP, so we should not           * We have modified the packet - it is now ESP, so we should not
          * return to UDP processing ...           * return to UDP processing ...
          *           *
          * Add a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember           * Add a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember
          * the source UDP port. This is required if we want           * the source UDP port. This is required if we want
          * to select the right SPD for multiple hosts behind           * to select the right SPD for multiple hosts behind
          * same NAT           * same NAT
          */           */
         if ((tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,          if ((tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,
             sizeof(sport) + sizeof(dport), M_DONTWAIT)) == NULL) {              sizeof(sport) + sizeof(dport), M_DONTWAIT)) == NULL) {
Line 1414  PR_WRAP_USRREQS(udp)
Line 1373  PR_WRAP_USRREQS(udp)
 #define udp_send        udp_send_wrapper  #define udp_send        udp_send_wrapper
 #define udp_sendoob     udp_sendoob_wrapper  #define udp_sendoob     udp_sendoob_wrapper
 #define udp_purgeif     udp_purgeif_wrapper  #define udp_purgeif     udp_purgeif_wrapper
 #define udp_usrreq      udp_usrreq_wrapper  
   
 const struct pr_usrreqs udp_usrreqs = {  const struct pr_usrreqs udp_usrreqs = {
         .pr_attach      = udp_attach,          .pr_attach      = udp_attach,
Line 1436  const struct pr_usrreqs udp_usrreqs = {
Line 1394  const struct pr_usrreqs udp_usrreqs = {
         .pr_send        = udp_send,          .pr_send        = udp_send,
         .pr_sendoob     = udp_sendoob,          .pr_sendoob     = udp_sendoob,
         .pr_purgeif     = udp_purgeif,          .pr_purgeif     = udp_purgeif,
         .pr_generic     = udp_usrreq,  
 };  };

Legend:
Removed from v.1.217  
changed lines
  Added in v.1.217.4.5

CVSweb <webmaster@jp.NetBSD.org>