The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet/udp_usrreq.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 4. Neither the name of the University nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      @(#)udp_usrreq.c        8.6 (Berkeley) 5/23/95
   30  * $FreeBSD: releng/5.4/sys/netinet/udp_usrreq.c 145955 2005-05-06 02:51:10Z cperciva $
   31  */
   32 
   33 #include "opt_ipsec.h"
   34 #include "opt_inet6.h"
   35 #include "opt_mac.h"
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/domain.h>
   40 #include <sys/jail.h>
   41 #include <sys/kernel.h>
   42 #include <sys/lock.h>
   43 #include <sys/mac.h>
   44 #include <sys/malloc.h>
   45 #include <sys/mbuf.h>
   46 #include <sys/proc.h>
   47 #include <sys/protosw.h>
   48 #include <sys/signalvar.h>
   49 #include <sys/socket.h>
   50 #include <sys/socketvar.h>
   51 #include <sys/sx.h>
   52 #include <sys/sysctl.h>
   53 #include <sys/syslog.h>
   54 
   55 #include <vm/uma.h>
   56 
   57 #include <net/if.h>
   58 #include <net/route.h>
   59 
   60 #include <netinet/in.h>
   61 #include <netinet/in_systm.h>
   62 #include <netinet/in_pcb.h>
   63 #include <netinet/in_var.h>
   64 #include <netinet/ip.h>
   65 #ifdef INET6
   66 #include <netinet/ip6.h>
   67 #endif
   68 #include <netinet/ip_icmp.h>
   69 #include <netinet/icmp_var.h>
   70 #include <netinet/ip_var.h>
   71 #ifdef INET6
   72 #include <netinet6/ip6_var.h>
   73 #endif
   74 #include <netinet/udp.h>
   75 #include <netinet/udp_var.h>
   76 
   77 #ifdef FAST_IPSEC
   78 #include <netipsec/ipsec.h>
   79 #endif /*FAST_IPSEC*/
   80 
   81 #ifdef IPSEC
   82 #include <netinet6/ipsec.h>
   83 #endif /*IPSEC*/
   84 
   85 #include <machine/in_cksum.h>
   86 
   87 /*
   88  * UDP protocol implementation.
   89  * Per RFC 768, August, 1980.
   90  */
   91 #ifndef COMPAT_42
   92 static int      udpcksum = 1;
   93 #else
   94 static int      udpcksum = 0;           /* XXX */
   95 #endif
   96 SYSCTL_INT(_net_inet_udp, UDPCTL_CHECKSUM, checksum, CTLFLAG_RW,
   97                 &udpcksum, 0, "");
   98 
   99 int     log_in_vain = 0;
  100 SYSCTL_INT(_net_inet_udp, OID_AUTO, log_in_vain, CTLFLAG_RW,
  101     &log_in_vain, 0, "Log all incoming UDP packets");
  102 
  103 static int      blackhole = 0;
  104 SYSCTL_INT(_net_inet_udp, OID_AUTO, blackhole, CTLFLAG_RW,
  105         &blackhole, 0, "Do not send port unreachables for refused connects");
  106 
  107 static int      strict_mcast_mship = 0;
  108 SYSCTL_INT(_net_inet_udp, OID_AUTO, strict_mcast_mship, CTLFLAG_RW,
  109         &strict_mcast_mship, 0, "Only send multicast to member sockets");
  110 
  111 struct  inpcbhead udb;          /* from udp_var.h */
  112 #define udb6    udb  /* for KAME src sync over BSD*'s */
  113 struct  inpcbinfo udbinfo;
  114 
  115 #ifndef UDBHASHSIZE
  116 #define UDBHASHSIZE 16
  117 #endif
  118 
  119 struct  udpstat udpstat;        /* from udp_var.h */
  120 SYSCTL_STRUCT(_net_inet_udp, UDPCTL_STATS, stats, CTLFLAG_RW,
  121     &udpstat, udpstat, "UDP statistics (struct udpstat, netinet/udp_var.h)");
  122 
  123 static void udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n,
  124                 int off, struct sockaddr_in *udp_in);
  125 
  126 static int udp_detach(struct socket *so);
  127 static  int udp_output(struct inpcb *, struct mbuf *, struct sockaddr *,
  128                 struct mbuf *, struct thread *);
  129 
  130 void
  131 udp_init()
  132 {
  133         INP_INFO_LOCK_INIT(&udbinfo, "udp");
  134         LIST_INIT(&udb);
  135         udbinfo.listhead = &udb;
  136         udbinfo.hashbase = hashinit(UDBHASHSIZE, M_PCB, &udbinfo.hashmask);
  137         udbinfo.porthashbase = hashinit(UDBHASHSIZE, M_PCB,
  138                                         &udbinfo.porthashmask);
  139         udbinfo.ipi_zone = uma_zcreate("udpcb", sizeof(struct inpcb), NULL,
  140             NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
  141         uma_zone_set_max(udbinfo.ipi_zone, maxsockets);
  142 }
  143 
  144 void
  145 udp_input(m, off)
  146         register struct mbuf *m;
  147         int off;
  148 {
  149         int iphlen = off;
  150         register struct ip *ip;
  151         register struct udphdr *uh;
  152         register struct inpcb *inp;
  153         struct mbuf *opts = 0;
  154         int len;
  155         struct ip save_ip;
  156         struct sockaddr_in udp_in;
  157 
  158         udpstat.udps_ipackets++;
  159 
  160         /*
  161          * Strip IP options, if any; should skip this,
  162          * make available to user, and use on returned packets,
  163          * but we don't yet have a way to check the checksum
  164          * with options still present.
  165          */
  166         if (iphlen > sizeof (struct ip)) {
  167                 ip_stripoptions(m, (struct mbuf *)0);
  168                 iphlen = sizeof(struct ip);
  169         }
  170 
  171         /*
  172          * Get IP and UDP header together in first mbuf.
  173          */
  174         ip = mtod(m, struct ip *);
  175         if (m->m_len < iphlen + sizeof(struct udphdr)) {
  176                 if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {
  177                         udpstat.udps_hdrops++;
  178                         return;
  179                 }
  180                 ip = mtod(m, struct ip *);
  181         }
  182         uh = (struct udphdr *)((caddr_t)ip + iphlen);
  183 
  184         /* destination port of 0 is illegal, based on RFC768. */
  185         if (uh->uh_dport == 0)
  186                 goto badunlocked;
  187 
  188         /*
  189          * Construct sockaddr format source address.
  190          * Stuff source address and datagram in user buffer.
  191          */
  192         bzero(&udp_in, sizeof(udp_in));
  193         udp_in.sin_len = sizeof(udp_in);
  194         udp_in.sin_family = AF_INET;
  195         udp_in.sin_port = uh->uh_sport;
  196         udp_in.sin_addr = ip->ip_src;
  197 
  198         /*
  199          * Make mbuf data length reflect UDP length.
  200          * If not enough data to reflect UDP length, drop.
  201          */
  202         len = ntohs((u_short)uh->uh_ulen);
  203         if (ip->ip_len != len) {
  204                 if (len > ip->ip_len || len < sizeof(struct udphdr)) {
  205                         udpstat.udps_badlen++;
  206                         goto badunlocked;
  207                 }
  208                 m_adj(m, len - ip->ip_len);
  209                 /* ip->ip_len = len; */
  210         }
  211         /*
  212          * Save a copy of the IP header in case we want restore it
  213          * for sending an ICMP error message in response.
  214          */
  215         if (!blackhole)
  216                 save_ip = *ip;
  217 
  218         /*
  219          * Checksum extended UDP header and data.
  220          */
  221         if (uh->uh_sum) {
  222                 if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID) {
  223                         if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR)
  224                                 uh->uh_sum = m->m_pkthdr.csum_data;
  225                         else
  226                                 uh->uh_sum = in_pseudo(ip->ip_src.s_addr,
  227                                     ip->ip_dst.s_addr, htonl((u_short)len +
  228                                     m->m_pkthdr.csum_data + IPPROTO_UDP));
  229                         uh->uh_sum ^= 0xffff;
  230                 } else {
  231                         char b[9];
  232                         bcopy(((struct ipovly *)ip)->ih_x1, b, 9);
  233                         bzero(((struct ipovly *)ip)->ih_x1, 9);
  234                         ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
  235                         uh->uh_sum = in_cksum(m, len + sizeof (struct ip));
  236                         bcopy(b, ((struct ipovly *)ip)->ih_x1, 9);
  237                 }
  238                 if (uh->uh_sum) {
  239                         udpstat.udps_badsum++;
  240                         m_freem(m);
  241                         return;
  242                 }
  243         } else
  244                 udpstat.udps_nosum++;
  245 
  246         INP_INFO_RLOCK(&udbinfo);
  247 
  248         if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) ||
  249             in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) {
  250                 struct inpcb *last;
  251                 /*
  252                  * Deliver a multicast or broadcast datagram to *all* sockets
  253                  * for which the local and remote addresses and ports match
  254                  * those of the incoming datagram.  This allows more than
  255                  * one process to receive multi/broadcasts on the same port.
  256                  * (This really ought to be done for unicast datagrams as
  257                  * well, but that would cause problems with existing
  258                  * applications that open both address-specific sockets and
  259                  * a wildcard socket listening to the same port -- they would
  260                  * end up receiving duplicates of every unicast datagram.
  261                  * Those applications open the multiple sockets to overcome an
  262                  * inadequacy of the UDP socket interface, but for backwards
  263                  * compatibility we avoid the problem here rather than
  264                  * fixing the interface.  Maybe 4.5BSD will remedy this?)
  265                  */
  266 
  267                 /*
  268                  * Locate pcb(s) for datagram.
  269                  * (Algorithm copied from raw_intr().)
  270                  */
  271                 last = NULL;
  272                 LIST_FOREACH(inp, &udb, inp_list) {
  273                         if (inp->inp_lport != uh->uh_dport)
  274                                 continue;
  275 #ifdef INET6
  276                         if ((inp->inp_vflag & INP_IPV4) == 0)
  277                                 continue;
  278 #endif
  279                         if (inp->inp_laddr.s_addr != INADDR_ANY) {
  280                                 if (inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
  281                                         continue;
  282                         }
  283                         if (inp->inp_faddr.s_addr != INADDR_ANY) {
  284                                 if (inp->inp_faddr.s_addr !=
  285                                     ip->ip_src.s_addr ||
  286                                     inp->inp_fport != uh->uh_sport)
  287                                         continue;
  288                         }
  289                         INP_LOCK(inp);
  290 
  291                         /*
  292                          * Check multicast packets to make sure they are only
  293                          * sent to sockets with multicast memberships for the
  294                          * packet's destination address and arrival interface
  295                          */
  296 #define MSHIP(_inp, n) ((_inp)->inp_moptions->imo_membership[(n)])
  297 #define NMSHIPS(_inp) ((_inp)->inp_moptions->imo_num_memberships)
  298                         if (strict_mcast_mship && inp->inp_moptions != NULL) {
  299                                 int mship, foundmship = 0;
  300 
  301                                 for (mship = 0; mship < NMSHIPS(inp); mship++) {
  302                                         if (MSHIP(inp, mship)->inm_addr.s_addr
  303                                             == ip->ip_dst.s_addr &&
  304                                             MSHIP(inp, mship)->inm_ifp
  305                                             == m->m_pkthdr.rcvif) {
  306                                                 foundmship = 1;
  307                                                 break;
  308                                         }
  309                                 }
  310                                 if (foundmship == 0) {
  311                                         INP_UNLOCK(inp);
  312                                         continue;
  313                                 }
  314                         }
  315 #undef NMSHIPS
  316 #undef MSHIP
  317                         if (last != NULL) {
  318                                 struct mbuf *n;
  319 
  320                                 n = m_copy(m, 0, M_COPYALL);
  321                                 if (n != NULL)
  322                                         udp_append(last, ip, n,
  323                                                    iphlen +
  324                                                    sizeof(struct udphdr),
  325                                                    &udp_in);
  326                                 INP_UNLOCK(last);
  327                         }
  328                         last = inp;
  329                         /*
  330                          * Don't look for additional matches if this one does
  331                          * not have either the SO_REUSEPORT or SO_REUSEADDR
  332                          * socket options set.  This heuristic avoids searching
  333                          * through all pcbs in the common case of a non-shared
  334                          * port.  It * assumes that an application will never
  335                          * clear these options after setting them.
  336                          */
  337                         if ((last->inp_socket->so_options&(SO_REUSEPORT|SO_REUSEADDR)) == 0)
  338                                 break;
  339                 }
  340 
  341                 if (last == NULL) {
  342                         /*
  343                          * No matching pcb found; discard datagram.
  344                          * (No need to send an ICMP Port Unreachable
  345                          * for a broadcast or multicast datgram.)
  346                          */
  347                         udpstat.udps_noportbcast++;
  348                         goto badheadlocked;
  349                 }
  350                 udp_append(last, ip, m, iphlen + sizeof(struct udphdr),
  351                     &udp_in);
  352                 INP_UNLOCK(last);
  353                 INP_INFO_RUNLOCK(&udbinfo);
  354                 return;
  355         }
  356         /*
  357          * Locate pcb for datagram.
  358          */
  359         inp = in_pcblookup_hash(&udbinfo, ip->ip_src, uh->uh_sport,
  360             ip->ip_dst, uh->uh_dport, 1, m->m_pkthdr.rcvif);
  361         if (inp == NULL) {
  362                 if (log_in_vain) {
  363                         char buf[4*sizeof "123"];
  364 
  365                         strcpy(buf, inet_ntoa(ip->ip_dst));
  366                         log(LOG_INFO,
  367                             "Connection attempt to UDP %s:%d from %s:%d\n",
  368                             buf, ntohs(uh->uh_dport), inet_ntoa(ip->ip_src),
  369                             ntohs(uh->uh_sport));
  370                 }
  371                 udpstat.udps_noport++;
  372                 if (m->m_flags & (M_BCAST | M_MCAST)) {
  373                         udpstat.udps_noportbcast++;
  374                         goto badheadlocked;
  375                 }
  376                 if (blackhole)
  377                         goto badheadlocked;
  378                 if (badport_bandlim(BANDLIM_ICMP_UNREACH) < 0)
  379                         goto badheadlocked;
  380                 *ip = save_ip;
  381                 ip->ip_len += iphlen;
  382                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0);
  383                 INP_INFO_RUNLOCK(&udbinfo);
  384                 return;
  385         }
  386         INP_LOCK(inp);
  387         udp_append(inp, ip, m, iphlen + sizeof(struct udphdr), &udp_in);
  388         INP_UNLOCK(inp);
  389         INP_INFO_RUNLOCK(&udbinfo);
  390         return;
  391 
  392 badheadlocked:
  393         if (inp)
  394                 INP_UNLOCK(inp);
  395         INP_INFO_RUNLOCK(&udbinfo);
  396 badunlocked:
  397         m_freem(m);
  398         if (opts)
  399                 m_freem(opts);
  400         return;
  401 }
  402 
  403 /*
  404  * Subroutine of udp_input(), which appends the provided mbuf chain to the
  405  * passed pcb/socket.  The caller must provide a sockaddr_in via udp_in that
  406  * contains the source address.  If the socket ends up being an IPv6 socket,
  407  * udp_append() will convert to a sockaddr_in6 before passing the address
  408  * into the socket code.
  409  */
  410 static void
  411 udp_append(last, ip, n, off, udp_in)
  412         struct inpcb *last;
  413         struct ip *ip;
  414         struct mbuf *n;
  415         int off;
  416         struct sockaddr_in *udp_in;
  417 {
  418         struct sockaddr *append_sa;
  419         struct socket *so;
  420         struct mbuf *opts = 0;
  421 #ifdef INET6
  422         struct sockaddr_in6 udp_in6;
  423 #endif
  424 
  425         INP_LOCK_ASSERT(last);
  426 
  427 #if defined(IPSEC) || defined(FAST_IPSEC)
  428         /* check AH/ESP integrity. */
  429         if (ipsec4_in_reject(n, last)) {
  430 #ifdef IPSEC
  431                 ipsecstat.in_polvio++;
  432 #endif /*IPSEC*/
  433                 m_freem(n);
  434                 return;
  435         }
  436 #endif /*IPSEC || FAST_IPSEC*/
  437 #ifdef MAC
  438         if (mac_check_inpcb_deliver(last, n) != 0) {
  439                 m_freem(n);
  440                 return;
  441         }
  442 #endif
  443         if (last->inp_flags & INP_CONTROLOPTS ||
  444             last->inp_socket->so_options & (SO_TIMESTAMP | SO_BINTIME)) {
  445 #ifdef INET6
  446                 if (last->inp_vflag & INP_IPV6) {
  447                         int savedflags;
  448 
  449                         savedflags = last->inp_flags;
  450                         last->inp_flags &= ~INP_UNMAPPABLEOPTS;
  451                         ip6_savecontrol(last, n, &opts);
  452                         last->inp_flags = savedflags;
  453                 } else
  454 #endif
  455                 ip_savecontrol(last, &opts, ip, n);
  456         }
  457 #ifdef INET6
  458         if (last->inp_vflag & INP_IPV6) {
  459                 bzero(&udp_in6, sizeof(udp_in6));
  460                 udp_in6.sin6_len = sizeof(udp_in6);
  461                 udp_in6.sin6_family = AF_INET6;
  462                 in6_sin_2_v4mapsin6(udp_in, &udp_in6);
  463                 append_sa = (struct sockaddr *)&udp_in6;
  464         } else
  465 #endif
  466         append_sa = (struct sockaddr *)udp_in;
  467         m_adj(n, off);
  468 
  469         so = last->inp_socket;
  470         SOCKBUF_LOCK(&so->so_rcv);
  471         if (sbappendaddr_locked(&so->so_rcv, append_sa, n, opts) == 0) {
  472                 m_freem(n);
  473                 if (opts)
  474                         m_freem(opts);
  475                 udpstat.udps_fullsock++;
  476                 SOCKBUF_UNLOCK(&so->so_rcv);
  477         } else
  478                 sorwakeup_locked(so);
  479 }
  480 
  481 /*
  482  * Notify a udp user of an asynchronous error;
  483  * just wake up so that he can collect error status.
  484  */
  485 struct inpcb *
  486 udp_notify(inp, errno)
  487         register struct inpcb *inp;
  488         int errno;
  489 {
  490         inp->inp_socket->so_error = errno;
  491         sorwakeup(inp->inp_socket);
  492         sowwakeup(inp->inp_socket);
  493         return inp;
  494 }
  495 
  496 void
  497 udp_ctlinput(cmd, sa, vip)
  498         int cmd;
  499         struct sockaddr *sa;
  500         void *vip;
  501 {
  502         struct ip *ip = vip;
  503         struct udphdr *uh;
  504         struct inpcb *(*notify)(struct inpcb *, int) = udp_notify;
  505         struct in_addr faddr;
  506         struct inpcb *inp;
  507         int s;
  508 
  509         faddr = ((struct sockaddr_in *)sa)->sin_addr;
  510         if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
  511                 return;
  512 
  513         /*
  514          * Redirects don't need to be handled up here.
  515          */
  516         if (PRC_IS_REDIRECT(cmd))
  517                 return;
  518         /*
  519          * Hostdead is ugly because it goes linearly through all PCBs.
  520          * XXX: We never get this from ICMP, otherwise it makes an
  521          * excellent DoS attack on machines with many connections.
  522          */
  523         if (cmd == PRC_HOSTDEAD)
  524                 ip = 0;
  525         else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0)
  526                 return;
  527         if (ip) {
  528                 s = splnet();
  529                 uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
  530                 INP_INFO_RLOCK(&udbinfo);
  531                 inp = in_pcblookup_hash(&udbinfo, faddr, uh->uh_dport,
  532                     ip->ip_src, uh->uh_sport, 0, NULL);
  533                 if (inp != NULL) {
  534                         INP_LOCK(inp);
  535                         if (inp->inp_socket != NULL) {
  536                                 (*notify)(inp, inetctlerrmap[cmd]);
  537                         }
  538                         INP_UNLOCK(inp);
  539                 }
  540                 INP_INFO_RUNLOCK(&udbinfo);
  541                 splx(s);
  542         } else
  543                 in_pcbnotifyall(&udbinfo, faddr, inetctlerrmap[cmd], notify);
  544 }
  545 
  546 static int
  547 udp_pcblist(SYSCTL_HANDLER_ARGS)
  548 {
  549         int error, i, n, s;
  550         struct inpcb *inp, **inp_list;
  551         inp_gen_t gencnt;
  552         struct xinpgen xig;
  553 
  554         /*
  555          * The process of preparing the TCB list is too time-consuming and
  556          * resource-intensive to repeat twice on every request.
  557          */
  558         if (req->oldptr == 0) {
  559                 n = udbinfo.ipi_count;
  560                 req->oldidx = 2 * (sizeof xig)
  561                         + (n + n/8) * sizeof(struct xinpcb);
  562                 return 0;
  563         }
  564 
  565         if (req->newptr != 0)
  566                 return EPERM;
  567 
  568         /*
  569          * OK, now we're committed to doing something.
  570          */
  571         s = splnet();
  572         INP_INFO_RLOCK(&udbinfo);
  573         gencnt = udbinfo.ipi_gencnt;
  574         n = udbinfo.ipi_count;
  575         INP_INFO_RUNLOCK(&udbinfo);
  576         splx(s);
  577 
  578         error = sysctl_wire_old_buffer(req, 2 * (sizeof xig)
  579                 + n * sizeof(struct xinpcb));
  580         if (error != 0)
  581                 return (error);
  582 
  583         xig.xig_len = sizeof xig;
  584         xig.xig_count = n;
  585         xig.xig_gen = gencnt;
  586         xig.xig_sogen = so_gencnt;
  587         error = SYSCTL_OUT(req, &xig, sizeof xig);
  588         if (error)
  589                 return error;
  590 
  591         inp_list = malloc(n * sizeof *inp_list, M_TEMP, M_WAITOK);
  592         if (inp_list == 0)
  593                 return ENOMEM;
  594 
  595         s = splnet();
  596         INP_INFO_RLOCK(&udbinfo);
  597         for (inp = LIST_FIRST(udbinfo.listhead), i = 0; inp && i < n;
  598              inp = LIST_NEXT(inp, inp_list)) {
  599                 INP_LOCK(inp);
  600                 if (inp->inp_gencnt <= gencnt &&
  601                     cr_canseesocket(req->td->td_ucred, inp->inp_socket) == 0)
  602                         inp_list[i++] = inp;
  603                 INP_UNLOCK(inp);
  604         }
  605         INP_INFO_RUNLOCK(&udbinfo);
  606         splx(s);
  607         n = i;
  608 
  609         error = 0;
  610         for (i = 0; i < n; i++) {
  611                 inp = inp_list[i];
  612                 if (inp->inp_gencnt <= gencnt) {
  613                         struct xinpcb xi;
  614                         bzero(&xi, sizeof(xi));
  615                         xi.xi_len = sizeof xi;
  616                         /* XXX should avoid extra copy */
  617                         bcopy(inp, &xi.xi_inp, sizeof *inp);
  618                         if (inp->inp_socket)
  619                                 sotoxsocket(inp->inp_socket, &xi.xi_socket);
  620                         xi.xi_inp.inp_gencnt = inp->inp_gencnt;
  621                         error = SYSCTL_OUT(req, &xi, sizeof xi);
  622                 }
  623         }
  624         if (!error) {
  625                 /*
  626                  * Give the user an updated idea of our state.
  627                  * If the generation differs from what we told
  628                  * her before, she knows that something happened
  629                  * while we were processing this request, and it
  630                  * might be necessary to retry.
  631                  */
  632                 s = splnet();
  633                 INP_INFO_RLOCK(&udbinfo);
  634                 xig.xig_gen = udbinfo.ipi_gencnt;
  635                 xig.xig_sogen = so_gencnt;
  636                 xig.xig_count = udbinfo.ipi_count;
  637                 INP_INFO_RUNLOCK(&udbinfo);
  638                 splx(s);
  639                 error = SYSCTL_OUT(req, &xig, sizeof xig);
  640         }
  641         free(inp_list, M_TEMP);
  642         return error;
  643 }
  644 
  645 SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist, CTLFLAG_RD, 0, 0,
  646             udp_pcblist, "S,xinpcb", "List of active UDP sockets");
  647 
  648 static int
  649 udp_getcred(SYSCTL_HANDLER_ARGS)
  650 {
  651         struct xucred xuc;
  652         struct sockaddr_in addrs[2];
  653         struct inpcb *inp;
  654         int error, s;
  655 
  656         error = suser_cred(req->td->td_ucred, SUSER_ALLOWJAIL);
  657         if (error)
  658                 return (error);
  659         error = SYSCTL_IN(req, addrs, sizeof(addrs));
  660         if (error)
  661                 return (error);
  662         s = splnet();
  663         INP_INFO_RLOCK(&udbinfo);
  664         inp = in_pcblookup_hash(&udbinfo, addrs[1].sin_addr, addrs[1].sin_port,
  665                                 addrs[0].sin_addr, addrs[0].sin_port, 1, NULL);
  666         if (inp == NULL || inp->inp_socket == NULL) {
  667                 error = ENOENT;
  668                 goto out;
  669         }
  670         error = cr_canseesocket(req->td->td_ucred, inp->inp_socket);
  671         if (error)
  672                 goto out;
  673         cru2x(inp->inp_socket->so_cred, &xuc);
  674 out:
  675         INP_INFO_RUNLOCK(&udbinfo);
  676         splx(s);
  677         if (error == 0)
  678                 error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
  679         return (error);
  680 }
  681 
  682 SYSCTL_PROC(_net_inet_udp, OID_AUTO, getcred,
  683     CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0,
  684     udp_getcred, "S,xucred", "Get the xucred of a UDP connection");
  685 
  686 static int
  687 udp_output(inp, m, addr, control, td)
  688         register struct inpcb *inp;
  689         struct mbuf *m;
  690         struct sockaddr *addr;
  691         struct mbuf *control;
  692         struct thread *td;
  693 {
  694         register struct udpiphdr *ui;
  695         register int len = m->m_pkthdr.len;
  696         struct in_addr faddr, laddr;
  697         struct cmsghdr *cm;
  698         struct sockaddr_in *sin, src;
  699         int error = 0;
  700         int ipflags;
  701         u_short fport, lport;
  702         int unlock_udbinfo;
  703 
  704         /*
  705          * udp_output() may need to temporarily bind or connect the current
  706          * inpcb.  As such, we don't know up front what inpcb locks we will
  707          * need.  Do any work to decide what is needed up front before
  708          * acquiring locks.
  709          */
  710         if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) {
  711                 if (control)
  712                         m_freem(control);
  713                 m_freem(m);
  714                 return EMSGSIZE;
  715         }
  716 
  717         src.sin_addr.s_addr = INADDR_ANY;
  718         if (control != NULL) {
  719                 /*
  720                  * XXX: Currently, we assume all the optional information
  721                  * is stored in a single mbuf.
  722                  */
  723                 if (control->m_next) {
  724                         m_freem(control);
  725                         m_freem(m);
  726                         return EINVAL;
  727                 }
  728                 for (; control->m_len > 0;
  729                     control->m_data += CMSG_ALIGN(cm->cmsg_len),
  730                     control->m_len -= CMSG_ALIGN(cm->cmsg_len)) {
  731                         cm = mtod(control, struct cmsghdr *);
  732                         if (control->m_len < sizeof(*cm) || cm->cmsg_len == 0 ||
  733                             cm->cmsg_len > control->m_len) {
  734                                 error = EINVAL;
  735                                 break;
  736                         }
  737                         if (cm->cmsg_level != IPPROTO_IP)
  738                                 continue;
  739 
  740                         switch (cm->cmsg_type) {
  741                         case IP_SENDSRCADDR:
  742                                 if (cm->cmsg_len !=
  743                                     CMSG_LEN(sizeof(struct in_addr))) {
  744                                         error = EINVAL;
  745                                         break;
  746                                 }
  747                                 bzero(&src, sizeof(src));
  748                                 src.sin_family = AF_INET;
  749                                 src.sin_len = sizeof(src);
  750                                 src.sin_port = inp->inp_lport;
  751                                 src.sin_addr = *(struct in_addr *)CMSG_DATA(cm);
  752                                 break;
  753                         default:
  754                                 error = ENOPROTOOPT;
  755                                 break;
  756                         }
  757                         if (error)
  758                                 break;
  759                 }
  760                 m_freem(control);
  761         }
  762         if (error) {
  763                 m_freem(m);
  764                 return error;
  765         }
  766 
  767         if (src.sin_addr.s_addr != INADDR_ANY ||
  768             addr != NULL) {
  769                 INP_INFO_WLOCK(&udbinfo);
  770                 unlock_udbinfo = 1;
  771         } else
  772                 unlock_udbinfo = 0;
  773         INP_LOCK(inp);
  774 
  775 #ifdef MAC
  776         mac_create_mbuf_from_inpcb(inp, m);
  777 #endif
  778 
  779         laddr = inp->inp_laddr;
  780         lport = inp->inp_lport;
  781         if (src.sin_addr.s_addr != INADDR_ANY) {
  782                 if (lport == 0) {
  783                         error = EINVAL;
  784                         goto release;
  785                 }
  786                 error = in_pcbbind_setup(inp, (struct sockaddr *)&src,
  787                     &laddr.s_addr, &lport, td->td_ucred);
  788                 if (error)
  789                         goto release;
  790         }
  791 
  792         if (addr) {
  793                 sin = (struct sockaddr_in *)addr;
  794                 if (td && jailed(td->td_ucred))
  795                         prison_remote_ip(td->td_ucred, 0, &sin->sin_addr.s_addr);
  796                 if (inp->inp_faddr.s_addr != INADDR_ANY) {
  797                         error = EISCONN;
  798                         goto release;
  799                 }
  800                 error = in_pcbconnect_setup(inp, addr, &laddr.s_addr, &lport,
  801                     &faddr.s_addr, &fport, NULL, td->td_ucred);
  802                 if (error)
  803                         goto release;
  804 
  805                 /* Commit the local port if newly assigned. */
  806                 if (inp->inp_laddr.s_addr == INADDR_ANY &&
  807                     inp->inp_lport == 0) {
  808                         /*
  809                          * Remember addr if jailed, to prevent rebinding.
  810                          */
  811                         if (jailed(td->td_ucred))
  812                                 inp->inp_laddr = laddr;
  813                         inp->inp_lport = lport;
  814                         if (in_pcbinshash(inp) != 0) {
  815                                 inp->inp_lport = 0;
  816                                 error = EAGAIN;
  817                                 goto release;
  818                         }
  819                         inp->inp_flags |= INP_ANONPORT;
  820                 }
  821         } else {
  822                 faddr = inp->inp_faddr;
  823                 fport = inp->inp_fport;
  824                 if (faddr.s_addr == INADDR_ANY) {
  825                         error = ENOTCONN;
  826                         goto release;
  827                 }
  828         }
  829 
  830         /*
  831          * Calculate data length and get a mbuf for UDP, IP, and possible
  832          * link-layer headers.  Immediate slide the data pointer back forward
  833          * since we won't use that space at this layer.
  834          */
  835         M_PREPEND(m, sizeof(struct udpiphdr) + max_linkhdr, M_DONTWAIT);
  836         if (m == NULL) {
  837                 error = ENOBUFS;
  838                 goto release;
  839         }
  840         m->m_data += max_linkhdr;
  841         m->m_len -= max_linkhdr;
  842         m->m_pkthdr.len -= max_linkhdr;
  843 
  844         /*
  845          * Fill in mbuf with extended UDP header
  846          * and addresses and length put into network format.
  847          */
  848         ui = mtod(m, struct udpiphdr *);
  849         bzero(ui->ui_x1, sizeof(ui->ui_x1));    /* XXX still needed? */
  850         ui->ui_pr = IPPROTO_UDP;
  851         ui->ui_src = laddr;
  852         ui->ui_dst = faddr;
  853         ui->ui_sport = lport;
  854         ui->ui_dport = fport;
  855         ui->ui_ulen = htons((u_short)len + sizeof(struct udphdr));
  856 
  857         ipflags = inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST);
  858         if (inp->inp_flags & INP_ONESBCAST)
  859                 ipflags |= IP_SENDONES;
  860 
  861         /*
  862          * Set up checksum and output datagram.
  863          */
  864         if (udpcksum) {
  865                 if (inp->inp_flags & INP_ONESBCAST)
  866                         faddr.s_addr = INADDR_BROADCAST;
  867                 ui->ui_sum = in_pseudo(ui->ui_src.s_addr, faddr.s_addr,
  868                     htons((u_short)len + sizeof(struct udphdr) + IPPROTO_UDP));
  869                 m->m_pkthdr.csum_flags = CSUM_UDP;
  870                 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
  871         } else {
  872                 ui->ui_sum = 0;
  873         }
  874         ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
  875         ((struct ip *)ui)->ip_ttl = inp->inp_ip_ttl;    /* XXX */
  876         ((struct ip *)ui)->ip_tos = inp->inp_ip_tos;    /* XXX */
  877         udpstat.udps_opackets++;
  878 
  879         if (unlock_udbinfo)
  880                 INP_INFO_WUNLOCK(&udbinfo);
  881         error = ip_output(m, inp->inp_options, NULL, ipflags,
  882             inp->inp_moptions, inp);
  883         INP_UNLOCK(inp);
  884         return (error);
  885 
  886 release:
  887         INP_UNLOCK(inp);
  888         if (unlock_udbinfo)
  889                 INP_INFO_WUNLOCK(&udbinfo);
  890         m_freem(m);
  891         return (error);
  892 }
  893 
  894 u_long  udp_sendspace = 9216;           /* really max datagram size */
  895                                         /* 40 1K datagrams */
  896 SYSCTL_INT(_net_inet_udp, UDPCTL_MAXDGRAM, maxdgram, CTLFLAG_RW,
  897     &udp_sendspace, 0, "Maximum outgoing UDP datagram size");
  898 
  899 u_long  udp_recvspace = 40 * (1024 +
  900 #ifdef INET6
  901                                       sizeof(struct sockaddr_in6)
  902 #else
  903                                       sizeof(struct sockaddr_in)
  904 #endif
  905                                       );
  906 SYSCTL_INT(_net_inet_udp, UDPCTL_RECVSPACE, recvspace, CTLFLAG_RW,
  907     &udp_recvspace, 0, "Maximum space for incoming UDP datagrams");
  908 
  909 static int
  910 udp_abort(struct socket *so)
  911 {
  912         struct inpcb *inp;
  913         int s;
  914 
  915         INP_INFO_WLOCK(&udbinfo);
  916         inp = sotoinpcb(so);
  917         if (inp == 0) {
  918                 INP_INFO_WUNLOCK(&udbinfo);
  919                 return EINVAL;  /* ??? possible? panic instead? */
  920         }
  921         INP_LOCK(inp);
  922         soisdisconnected(so);
  923         s = splnet();
  924         in_pcbdetach(inp);
  925         INP_INFO_WUNLOCK(&udbinfo);
  926         splx(s);
  927         return 0;
  928 }
  929 
  930 static int
  931 udp_attach(struct socket *so, int proto, struct thread *td)
  932 {
  933         struct inpcb *inp;
  934         int s, error;
  935 
  936         INP_INFO_WLOCK(&udbinfo);
  937         inp = sotoinpcb(so);
  938         if (inp != 0) {
  939                 INP_INFO_WUNLOCK(&udbinfo);
  940                 return EINVAL;
  941         }
  942         error = soreserve(so, udp_sendspace, udp_recvspace);
  943         if (error) {
  944                 INP_INFO_WUNLOCK(&udbinfo);
  945                 return error;
  946         }
  947         s = splnet();
  948         error = in_pcballoc(so, &udbinfo, "udpinp");
  949         splx(s);
  950         if (error) {
  951                 INP_INFO_WUNLOCK(&udbinfo);
  952                 return error;
  953         }
  954 
  955         inp = (struct inpcb *)so->so_pcb;
  956         INP_LOCK(inp);
  957         INP_INFO_WUNLOCK(&udbinfo);
  958         inp->inp_vflag |= INP_IPV4;
  959         inp->inp_ip_ttl = ip_defttl;
  960         INP_UNLOCK(inp);
  961         return 0;
  962 }
  963 
  964 static int
  965 udp_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
  966 {
  967         struct inpcb *inp;
  968         int s, error;
  969 
  970         INP_INFO_WLOCK(&udbinfo);
  971         inp = sotoinpcb(so);
  972         if (inp == 0) {
  973                 INP_INFO_WUNLOCK(&udbinfo);
  974                 return EINVAL;
  975         }
  976         INP_LOCK(inp);
  977         s = splnet();
  978         error = in_pcbbind(inp, nam, td->td_ucred);
  979         splx(s);
  980         INP_UNLOCK(inp);
  981         INP_INFO_WUNLOCK(&udbinfo);
  982         return error;
  983 }
  984 
  985 static int
  986 udp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
  987 {
  988         struct inpcb *inp;
  989         int s, error;
  990         struct sockaddr_in *sin;
  991 
  992         INP_INFO_WLOCK(&udbinfo);
  993         inp = sotoinpcb(so);
  994         if (inp == 0) {
  995                 INP_INFO_WUNLOCK(&udbinfo);
  996                 return EINVAL;
  997         }
  998         INP_LOCK(inp);
  999         if (inp->inp_faddr.s_addr != INADDR_ANY) {
 1000                 INP_UNLOCK(inp);
 1001                 INP_INFO_WUNLOCK(&udbinfo);
 1002                 return EISCONN;
 1003         }
 1004         s = splnet();
 1005         sin = (struct sockaddr_in *)nam;
 1006         if (td && jailed(td->td_ucred))
 1007                 prison_remote_ip(td->td_ucred, 0, &sin->sin_addr.s_addr);
 1008         error = in_pcbconnect(inp, nam, td->td_ucred);
 1009         splx(s);
 1010         if (error == 0)
 1011                 soisconnected(so);
 1012         INP_UNLOCK(inp);
 1013         INP_INFO_WUNLOCK(&udbinfo);
 1014         return error;
 1015 }
 1016 
 1017 static int
 1018 udp_detach(struct socket *so)
 1019 {
 1020         struct inpcb *inp;
 1021         int s;
 1022 
 1023         INP_INFO_WLOCK(&udbinfo);
 1024         inp = sotoinpcb(so);
 1025         if (inp == 0) {
 1026                 INP_INFO_WUNLOCK(&udbinfo);
 1027                 return EINVAL;
 1028         }
 1029         INP_LOCK(inp);
 1030         s = splnet();
 1031         in_pcbdetach(inp);
 1032         INP_INFO_WUNLOCK(&udbinfo);
 1033         splx(s);
 1034         return 0;
 1035 }
 1036 
 1037 static int
 1038 udp_disconnect(struct socket *so)
 1039 {
 1040         struct inpcb *inp;
 1041         int s;
 1042 
 1043         INP_INFO_WLOCK(&udbinfo);
 1044         inp = sotoinpcb(so);
 1045         if (inp == 0) {
 1046                 INP_INFO_WUNLOCK(&udbinfo);
 1047                 return EINVAL;
 1048         }
 1049         INP_LOCK(inp);
 1050         if (inp->inp_faddr.s_addr == INADDR_ANY) {
 1051                 INP_INFO_WUNLOCK(&udbinfo);
 1052                 INP_UNLOCK(inp);
 1053                 return ENOTCONN;
 1054         }
 1055 
 1056         s = splnet();
 1057         in_pcbdisconnect(inp);
 1058         inp->inp_laddr.s_addr = INADDR_ANY;
 1059         INP_UNLOCK(inp);
 1060         INP_INFO_WUNLOCK(&udbinfo);
 1061         splx(s);
 1062         so->so_state &= ~SS_ISCONNECTED;                /* XXX */
 1063         return 0;
 1064 }
 1065 
 1066 static int
 1067 udp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 1068             struct mbuf *control, struct thread *td)
 1069 {
 1070         struct inpcb *inp;
 1071 
 1072         inp = sotoinpcb(so);
 1073         return udp_output(inp, m, addr, control, td);
 1074 }
 1075 
 1076 int
 1077 udp_shutdown(struct socket *so)
 1078 {
 1079         struct inpcb *inp;
 1080 
 1081         INP_INFO_RLOCK(&udbinfo);
 1082         inp = sotoinpcb(so);
 1083         if (inp == 0) {
 1084                 INP_INFO_RUNLOCK(&udbinfo);
 1085                 return EINVAL;
 1086         }
 1087         INP_LOCK(inp);
 1088         INP_INFO_RUNLOCK(&udbinfo);
 1089         socantsendmore(so);
 1090         INP_UNLOCK(inp);
 1091         return 0;
 1092 }
 1093 
 1094 /*
 1095  * This is the wrapper function for in_setsockaddr.  We just pass down
 1096  * the pcbinfo for in_setsockaddr to lock.  We don't want to do the locking
 1097  * here because in_setsockaddr will call malloc and might block.
 1098  */
 1099 static int
 1100 udp_sockaddr(struct socket *so, struct sockaddr **nam)
 1101 {
 1102         return (in_setsockaddr(so, nam, &udbinfo));
 1103 }
 1104 
 1105 /*
 1106  * This is the wrapper function for in_setpeeraddr.  We just pass down
 1107  * the pcbinfo for in_setpeeraddr to lock.
 1108  */
 1109 static int
 1110 udp_peeraddr(struct socket *so, struct sockaddr **nam)
 1111 {
 1112         return (in_setpeeraddr(so, nam, &udbinfo));
 1113 }
 1114 
 1115 struct pr_usrreqs udp_usrreqs = {
 1116         udp_abort, pru_accept_notsupp, udp_attach, udp_bind, udp_connect,
 1117         pru_connect2_notsupp, in_control, udp_detach, udp_disconnect,
 1118         pru_listen_notsupp, udp_peeraddr, pru_rcvd_notsupp,
 1119         pru_rcvoob_notsupp, udp_send, pru_sense_null, udp_shutdown,
 1120         udp_sockaddr, sosend, soreceive, sopoll, in_pcbsosetlabel
 1121 };

Cache object: 894a1a3aa27bbb2d7be7631754766b4e


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.