bsd/netinet6/udp6_usrreq.c

   1 /*      $FreeBSD: src/sys/netinet6/udp6_usrreq.c,v 1.6.2.6 2001/07/29 19:32:40 ume Exp $        */
   2 /*      $KAME: udp6_usrreq.c,v 1.27 2001/05/21 05:45:10 jinmei Exp $    */
   3
   4 /*
   5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the project nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Copyright (c) 1982, 1986, 1989, 1993
  35  *      The Regents of the University of California.  All rights reserved.
  36  *
  37  * Redistribution and use in source and binary forms, with or without
  38  * modification, are permitted provided that the following conditions
  39  * are met:
  40  * 1. Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  * 2. Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in the
  44  *    documentation and/or other materials provided with the distribution.
  45  * 3. All advertising materials mentioning features or use of this software
  46  *    must display the following acknowledgement:
  47  *      This product includes software developed by the University of
  48  *      California, Berkeley and its contributors.
  49  * 4. Neither the name of the University nor the names of its contributors
  50  *    may be used to endorse or promote products derived from this software
  51  *    without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  56  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  57  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  58  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  59  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  63  * SUCH DAMAGE.
  64  *
  65  *      @(#)udp_var.h   8.1 (Berkeley) 6/10/93
  66  */
  67
  68 #include <sys/param.h>
  69 #include <sys/kernel.h>
  70 #include <sys/malloc.h>
  71 #include <sys/mbuf.h>
  72 #include <sys/protosw.h>
  73 #include <sys/socket.h>
  74 #include <sys/socketvar.h>
  75 #include <sys/sysctl.h>
  76 #include <sys/errno.h>
  77 #include <sys/stat.h>
  78 #include <sys/systm.h>
  79 #include <sys/syslog.h>
  80 #include <sys/proc.h>
  81
  82 #include <net/if.h>
  83 #include <net/route.h>
  84 #include <net/if_types.h>
  85
  86 #include <netinet/in.h>
  87 #include <netinet/in_systm.h>
  88 #include <netinet/ip.h>
  89 #include <netinet/in_pcb.h>
  90 #include <netinet/in_var.h>
  91 #include <netinet/ip_var.h>
  92 #include <netinet/udp.h>
  93 #include <netinet/udp_var.h>
  94 #include <netinet/ip6.h>
  95 #include <netinet6/ip6_var.h>
  96 #include <netinet6/in6_pcb.h>
  97 #include <netinet/icmp6.h>
  98 #include <netinet6/udp6_var.h>
  99 #include <netinet6/ip6protosw.h>
 100
 101 #if IPSEC
 102 #include <netinet6/ipsec.h>
 103 #include <netinet6/ipsec6.h>
 104 extern int ipsec_bypass;
 105 #endif /*IPSEC*/
 106
 107 #include "faith.h"
 108 #if defined(NFAITH) && NFAITH > 0
 109 #include <net/if_faith.h>
 110 #endif
 111
 112 /*
 113  * UDP protocol inplementation.
 114  * Per RFC 768, August, 1980.
 115  */
 116
 117 extern  struct protosw inetsw[];
 118 static  int in6_mcmatch __P((struct inpcb *, struct in6_addr *, struct ifnet *));
 119 static  int udp6_detach __P((struct socket *so));
 120
 121 static int
 122 in6_mcmatch(in6p, ia6, ifp)
 123         struct inpcb *in6p;
 124         register struct in6_addr *ia6;
 125         struct ifnet *ifp;
 126 {
 127         struct ip6_moptions *im6o = in6p->in6p_moptions;
 128         struct in6_multi_mship *imm;
 129
 130         if (im6o == NULL)
 131                 return 0;
 132
 133         for (imm = im6o->im6o_memberships.lh_first; imm != NULL;
 134              imm = imm->i6mm_chain.le_next) {
 135                 if ((ifp == NULL ||
 136                      imm->i6mm_maddr->in6m_ifp == ifp) &&
 137                     IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
 138                                        ia6))
 139                         return 1;
 140         }
 141         return 0;
 142 }
 143
 144 int
 145 udp6_input(mp, offp, proto)
 146         struct mbuf **mp;
 147         int *offp, proto;
 148 {
 149         struct mbuf *m = *mp;
 150         register struct ip6_hdr *ip6;
 151         register struct udphdr *uh;
 152         register struct inpcb *in6p;
 153         struct  mbuf *opts = NULL;
 154         int off = *offp;
 155         int plen, ulen;
 156         struct sockaddr_in6 udp_in6;
 157
 158         IP6_EXTHDR_CHECK(m, off, sizeof(struct udphdr), IPPROTO_DONE);
 159
 160         ip6 = mtod(m, struct ip6_hdr *);
 161
 162 #if defined(NFAITH) && 0 < NFAITH
 163         if (faithprefix(&ip6->ip6_dst)) {
 164                 /* XXX send icmp6 host/port unreach? */
 165                 m_freem(m);
 166                 return IPPROTO_DONE;
 167         }
 168 #endif
 169
 170         udpstat.udps_ipackets++;
 171
 172         plen = ntohs(ip6->ip6_plen) - off + sizeof(*ip6);
 173         uh = (struct udphdr *)((caddr_t)ip6 + off);
 174         ulen = ntohs((u_short)uh->uh_ulen);
 175
 176         if (plen != ulen) {
 177                 udpstat.udps_badlen++;
 178                 goto bad;
 179         }
 180
 181         /*
 182          * Checksum extended UDP header and data.
 183          */
 184 #ifndef __APPLE__
 185         if (uh->uh_sum == 0)
 186                 udpstat.udps_nosum++;
 187 #endif
 188         else if (in6_cksum(m, IPPROTO_UDP, off, ulen) != 0) {
 189                 udpstat.udps_badsum++;
 190                 goto bad;
 191         }
 192
 193         if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
 194                 struct  inpcb *last;
 195
 196                 /*
 197                  * Deliver a multicast datagram to all sockets
 198                  * for which the local and remote addresses and ports match
 199                  * those of the incoming datagram.  This allows more than
 200                  * one process to receive multicasts on the same port.
 201                  * (This really ought to be done for unicast datagrams as
 202                  * well, but that would cause problems with existing
 203                  * applications that open both address-specific sockets and
 204                  * a wildcard socket listening to the same port -- they would
 205                  * end up receiving duplicates of every unicast datagram.
 206                  * Those applications open the multiple sockets to overcome an
 207                  * inadequacy of the UDP socket interface, but for backwards
 208                  * compatibility we avoid the problem here rather than
 209                  * fixing the interface.  Maybe 4.5BSD will remedy this?)
 210                  */
 211
 212                 /*
 213                  * In a case that laddr should be set to the link-local
 214                  * address (this happens in RIPng), the multicast address
 215                  * specified in the received packet does not match with
 216                  * laddr. To cure this situation, the matching is relaxed
 217                  * if the receiving interface is the same as one specified
 218                  * in the socket and if the destination multicast address
 219                  * matches one of the multicast groups specified in the socket.
 220                  */
 221
 222                 /*
 223                  * Construct sockaddr format source address.
 224                  */
 225                 init_sin6(&udp_in6, m); /* general init */
 226                 udp_in6.sin6_port = uh->uh_sport;
 227                 /*
 228                  * KAME note: usually we drop udphdr from mbuf here.
 229                  * We need udphdr for IPsec processing so we do that later.
 230                  */
 231
 232                 /*
 233                  * Locate pcb(s) for datagram.
 234                  * (Algorithm copied from raw_intr().)
 235                  */
 236                 last = NULL;
 237                 LIST_FOREACH(in6p, &udb, inp_list) {
 238                         if ((in6p->inp_vflag & INP_IPV6) == 0)
 239                                 continue;
 240                         if (in6p->in6p_lport != uh->uh_dport)
 241                                 continue;
 242                         if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {
 243                                 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr,
 244                                                         &ip6->ip6_dst) &&
 245                                     !in6_mcmatch(in6p, &ip6->ip6_dst,
 246                                                  m->m_pkthdr.rcvif))
 247                                         continue;
 248                         }
 249                         if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
 250                                 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr,
 251                                                         &ip6->ip6_src) ||
 252                                    in6p->in6p_fport != uh->uh_sport)
 253                                         continue;
 254                         }
 255
 256                         if (last != NULL) {
 257                                 struct  mbuf *n;
 258
 259 #if IPSEC
 260                                 /*
 261                                  * Check AH/ESP integrity.
 262                                  */
 263                                 if (ipsec_bypass == 0 && ipsec6_in_reject_so(m, last->inp_socket))
 264                                         ipsec6stat.in_polvio++;
 265                                         /* do not inject data into pcb */
 266                                 else
 267 #endif /*IPSEC*/
 268                                 if ((n = m_copy(m, 0, M_COPYALL)) != NULL) {
 269                                         /*
 270                                          * KAME NOTE: do not
 271                                          * m_copy(m, offset, ...) above.
 272                                          * sbappendaddr() expects M_PKTHDR,
 273                                          * and m_copy() will copy M_PKTHDR
 274                                          * only if offset is 0.
 275                                          */
 276                                         if (last->in6p_flags & IN6P_CONTROLOPTS
 277                                             || last->in6p_socket->so_options & SO_TIMESTAMP)
 278                                                 ip6_savecontrol(last, &opts,
 279                                                                 ip6, n);
 280
 281                                         m_adj(n, off + sizeof(struct udphdr));
 282                                         if (sbappendaddr(&last->in6p_socket->so_rcv,
 283                                                         (struct sockaddr *)&udp_in6,
 284                                                         n, opts) == 0) {
 285                                                 m_freem(n);
 286                                                 if (opts)
 287                                                         m_freem(opts);
 288                                                 udpstat.udps_fullsock++;
 289                                         } else
 290                                                 sorwakeup(last->in6p_socket);
 291                                         opts = NULL;
 292                                 }
 293                         }
 294                         last = in6p;
 295                         /*
 296                          * Don't look for additional matches if this one does
 297                          * not have either the SO_REUSEPORT or SO_REUSEADDR
 298                          * socket options set.  This heuristic avoids searching
 299                          * through all pcbs in the common case of a non-shared
 300                          * port.  It assumes that an application will never
 301                          * clear these options after setting them.
 302                          */
 303                         if ((last->in6p_socket->so_options &
 304                              (SO_REUSEPORT|SO_REUSEADDR)) == 0)
 305                                 break;
 306                 }
 307
 308                 if (last == NULL) {
 309                         /*
 310                          * No matching pcb found; discard datagram.
 311                          * (No need to send an ICMP Port Unreachable
 312                          * for a broadcast or multicast datgram.)
 313                          */
 314                         udpstat.udps_noport++;
 315 #ifndef __APPLE__
 316                         udpstat.udps_noportmcast++;
 317 #endif
 318                         goto bad;
 319                 }
 320 #if IPSEC
 321                 /*
 322                  * Check AH/ESP integrity.
 323                  */
 324                 if (ipsec_bypass == 0 && ipsec6_in_reject_so(m, last->inp_socket)) {
 325                         ipsec6stat.in_polvio++;
 326                         goto bad;
 327                 }
 328 #endif /*IPSEC*/
 329                 if (last->in6p_flags & IN6P_CONTROLOPTS
 330                     || last->in6p_socket->so_options & SO_TIMESTAMP)
 331                         ip6_savecontrol(last, &opts, ip6, m);
 332
 333                 m_adj(m, off + sizeof(struct udphdr));
 334                 if (sbappendaddr(&last->in6p_socket->so_rcv,
 335                                 (struct sockaddr *)&udp_in6,
 336                                 m, opts) == 0) {
 337                         udpstat.udps_fullsock++;
 338                         goto bad;
 339                 }
 340                 sorwakeup(last->in6p_socket);
 341                 return IPPROTO_DONE;
 342         }
 343         /*
 344          * Locate pcb for datagram.
 345          */
 346         in6p = in6_pcblookup_hash(&udbinfo, &ip6->ip6_src, uh->uh_sport,
 347                                   &ip6->ip6_dst, uh->uh_dport, 1,
 348                                   m->m_pkthdr.rcvif);
 349         if (in6p == 0) {
 350                 if (log_in_vain) {
 351                         char buf[INET6_ADDRSTRLEN];
 352
 353                         strcpy(buf, ip6_sprintf(&ip6->ip6_dst));
 354                         log(LOG_INFO,
 355                             "Connection attempt to UDP %s:%d from %s:%d\n",
 356                             buf, ntohs(uh->uh_dport),
 357                             ip6_sprintf(&ip6->ip6_src), ntohs(uh->uh_sport));
 358                 }
 359                 udpstat.udps_noport++;
 360                 if (m->m_flags & M_MCAST) {
 361                         printf("UDP6: M_MCAST is set in a unicast packet.\n");
 362 #ifndef __APPLE__
 363                         udpstat.udps_noportmcast++;
 364 #endif
 365                         goto bad;
 366                 }
 367                 icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
 368                 return IPPROTO_DONE;
 369         }
 370 #if IPSEC
 371         /*
 372          * Check AH/ESP integrity.
 373          */
 374         if (ipsec_bypass == 0 && ipsec6_in_reject_so(m, in6p->in6p_socket)) {
 375                 ipsec6stat.in_polvio++;
 376                 goto bad;
 377         }
 378 #endif /*IPSEC*/
 379
 380         /*
 381          * Construct sockaddr format source address.
 382          * Stuff source address and datagram in user buffer.
 383          */
 384         init_sin6(&udp_in6, m); /* general init */
 385         udp_in6.sin6_port = uh->uh_sport;
 386         if (in6p->in6p_flags & IN6P_CONTROLOPTS
 387             || in6p->in6p_socket->so_options & SO_TIMESTAMP)
 388                 ip6_savecontrol(in6p, &opts, ip6, m);
 389         m_adj(m, off + sizeof(struct udphdr));
 390         if (sbappendaddr(&in6p->in6p_socket->so_rcv,
 391                         (struct sockaddr *)&udp_in6,
 392                         m, opts) == 0) {
 393                 udpstat.udps_fullsock++;
 394                 goto bad;
 395         }
 396         sorwakeup(in6p->in6p_socket);
 397         return IPPROTO_DONE;
 398 bad:
 399         if (m)
 400                 m_freem(m);
 401         if (opts)
 402                 m_freem(opts);
 403         return IPPROTO_DONE;
 404 }
 405
 406 void
 407 udp6_ctlinput(cmd, sa, d)
 408         int cmd;
 409         struct sockaddr *sa;
 410         void *d;
 411 {
 412         struct udphdr uh;
 413         struct ip6_hdr *ip6;
 414         struct mbuf *m;
 415         int off = 0;
 416         struct ip6ctlparam *ip6cp = NULL;
 417         const struct sockaddr_in6 *sa6_src = NULL;
 418         void (*notify) __P((struct inpcb *, int)) = udp_notify;
 419         struct udp_portonly {
 420                 u_int16_t uh_sport;
 421                 u_int16_t uh_dport;
 422         } *uhp;
 423
 424         if (sa->sa_family != AF_INET6 ||
 425             sa->sa_len != sizeof(struct sockaddr_in6))
 426                 return;
 427
 428         if ((unsigned)cmd >= PRC_NCMDS)
 429                 return;
 430         if (PRC_IS_REDIRECT(cmd))
 431                 notify = in6_rtchange, d = NULL;
 432         else if (cmd == PRC_HOSTDEAD)
 433                 d = NULL;
 434         else if (inet6ctlerrmap[cmd] == 0)
 435                 return;
 436
 437         /* if the parameter is from icmp6, decode it. */
 438         if (d != NULL) {
 439                 ip6cp = (struct ip6ctlparam *)d;
 440                 m = ip6cp->ip6c_m;
 441                 ip6 = ip6cp->ip6c_ip6;
 442                 off = ip6cp->ip6c_off;
 443                 sa6_src = ip6cp->ip6c_src;
 444         } else {
 445                 m = NULL;
 446                 ip6 = NULL;
 447                 sa6_src = &sa6_any;
 448         }
 449
 450         if (ip6) {
 451                 /*
 452                  * XXX: We assume that when IPV6 is non NULL,
 453                  * M and OFF are valid.
 454                  */
 455
 456                 /* check if we can safely examine src and dst ports */
 457                 if (m->m_pkthdr.len < off + sizeof(*uhp))
 458                         return;
 459
 460                 bzero(&uh, sizeof(uh));
 461                 m_copydata(m, off, sizeof(*uhp), (caddr_t)&uh);
 462
 463                 (void) in6_pcbnotify(&udb, sa, uh.uh_dport,
 464                                         (struct sockaddr*)ip6cp->ip6c_src,
 465                                         uh.uh_sport, cmd, notify);
 466         } else
 467                 (void) in6_pcbnotify(&udb, sa, 0, (struct sockaddr *)&sa6_src,
 468                                      0, cmd, notify);
 469 }
 470
 471 #ifndef __APPLE__
 472 static int
 473 udp6_getcred SYSCTL_HANDLER_ARGS
 474 {
 475         struct sockaddr_in6 addrs[2];
 476         struct inpcb *inp;
 477         int error, s;
 478
 479         error = suser(req->p->p_ucred, &req->p->p_acflag);
 480         if (error)
 481                 return (error);
 482
 483         if (req->newlen != sizeof(addrs))
 484                 return (EINVAL);
 485         if (req->oldlen != sizeof(struct ucred))
 486                 return (EINVAL);
 487         error = SYSCTL_IN(req, addrs, sizeof(addrs));
 488         if (error)
 489                 return (error);
 490         s = splnet();
 491         inp = in6_pcblookup_hash(&udbinfo, &addrs[1].sin6_addr,
 492                                  addrs[1].sin6_port,
 493                                  &addrs[0].sin6_addr, addrs[0].sin6_port,
 494                                  1, NULL);
 495         if (!inp || !inp->inp_socket || !inp->inp_socket->so_cred) {
 496                 error = ENOENT;
 497                 goto out;
 498         }
 499         error = SYSCTL_OUT(req, inp->inp_socket->so_cred->pc_ucred,
 500                            sizeof(struct ucred));
 501
 502 out:
 503         splx(s);
 504         return (error);
 505 }
 506
 507 SYSCTL_PROC(_net_inet6_udp6, OID_AUTO, getcred, CTLTYPE_OPAQUE|CTLFLAG_RW,
 508             0, 0,
 509             udp6_getcred, "S,ucred", "Get the ucred of a UDP6 connection");
 510 #endif
 511
 512 static int
 513 udp6_abort(struct socket *so)
 514 {
 515         struct inpcb *inp;
 516         int s;
 517
 518         inp = sotoinpcb(so);
 519         if (inp == 0)
 520                 return EINVAL;  /* ??? possible? panic instead? */
 521         soisdisconnected(so);
 522         s = splnet();
 523         in6_pcbdetach(inp);
 524         splx(s);
 525         return 0;
 526 }
 527
 528 static int
 529 udp6_attach(struct socket *so, int proto, struct proc *p)
 530 {
 531         struct inpcb *inp;
 532         int s, error;
 533
 534         inp = sotoinpcb(so);
 535         if (inp != 0)
 536                 return EINVAL;
 537
 538         if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
 539                 error = soreserve(so, udp_sendspace, udp_recvspace);
 540                 if (error)
 541                         return error;
 542         }
 543         s = splnet();
 544         error = in_pcballoc(so, &udbinfo, p);
 545         splx(s);
 546         if (error)
 547                 return error;
 548         inp = (struct inpcb *)so->so_pcb;
 549         inp->inp_vflag |= INP_IPV6;
 550         inp->in6p_hops = -1;    /* use kernel default */
 551         inp->in6p_cksum = -1;   /* just to be sure */
 552         /*
 553          * XXX: ugly!!
 554          * IPv4 TTL initialization is necessary for an IPv6 socket as well,
 555          * because the socket may be bound to an IPv6 wildcard address,
 556          * which may match an IPv4-mapped IPv6 address.
 557          */
 558         inp->inp_ip_ttl = ip_defttl;
 559         return 0;
 560 }
 561
 562 static int
 563 udp6_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
 564 {
 565         struct inpcb *inp;
 566         int s, error;
 567
 568         inp = sotoinpcb(so);
 569         if (inp == 0)
 570                 return EINVAL;
 571
 572         inp->inp_vflag &= ~INP_IPV4;
 573         inp->inp_vflag |= INP_IPV6;
 574         if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) {
 575                 struct sockaddr_in6 *sin6_p;
 576
 577                 sin6_p = (struct sockaddr_in6 *)nam;
 578
 579                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p->sin6_addr))
 580                         inp->inp_vflag |= INP_IPV4;
 581                 else if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) {
 582                         struct sockaddr_in sin;
 583
 584                         in6_sin6_2_sin(&sin, sin6_p);
 585                         inp->inp_vflag |= INP_IPV4;
 586                         inp->inp_vflag &= ~INP_IPV6;
 587                         s = splnet();
 588                         error = in_pcbbind(inp, (struct sockaddr *)&sin, p);
 589                         splx(s);
 590                         return error;
 591                 }
 592         }
 593
 594         s = splnet();
 595         error = in6_pcbbind(inp, nam, p);
 596         splx(s);
 597         return error;
 598 }
 599
 600 static int
 601 udp6_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
 602 {
 603         struct inpcb *inp;
 604         int s, error;
 605
 606         inp = sotoinpcb(so);
 607         if (inp == 0)
 608                 return EINVAL;
 609
 610         if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) {
 611                 struct sockaddr_in6 *sin6_p;
 612
 613                 sin6_p = (struct sockaddr_in6 *)nam;
 614                 if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) {
 615                         struct sockaddr_in sin;
 616
 617                         if (inp->inp_faddr.s_addr != INADDR_ANY)
 618                                 return EISCONN;
 619                         in6_sin6_2_sin(&sin, sin6_p);
 620                         s = splnet();
 621                         error = in_pcbconnect(inp, (struct sockaddr *)&sin, p);
 622                         splx(s);
 623                         if (error == 0) {
 624                                 inp->inp_vflag |= INP_IPV4;
 625                                 inp->inp_vflag &= ~INP_IPV6;
 626                                 soisconnected(so);
 627                         }
 628                         return error;
 629                 }
 630         }
 631
 632         if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))
 633                 return EISCONN;
 634         s = splnet();
 635         error = in6_pcbconnect(inp, nam, p);
 636         splx(s);
 637         if (error == 0) {
 638                 if (ip6_mapped_addr_on) { /* should be non mapped addr */
 639                         inp->inp_vflag &= ~INP_IPV4;
 640                         inp->inp_vflag |= INP_IPV6;
 641                 }
 642                 soisconnected(so);
 643         }
 644         return error;
 645 }
 646
 647 static int
 648 udp6_detach(struct socket *so)
 649 {
 650         struct inpcb *inp;
 651         int s;
 652
 653         inp = sotoinpcb(so);
 654         if (inp == 0)
 655                 return EINVAL;
 656         s = splnet();
 657         in6_pcbdetach(inp);
 658         splx(s);
 659         return 0;
 660 }
 661
 662 static int
 663 udp6_disconnect(struct socket *so)
 664 {
 665         struct inpcb *inp;
 666         int s;
 667
 668         inp = sotoinpcb(so);
 669         if (inp == 0)
 670                 return EINVAL;
 671
 672         if (inp->inp_vflag & INP_IPV4) {
 673                 struct pr_usrreqs *pru;
 674
 675                 pru = ip_protox[IPPROTO_UDP]->pr_usrreqs;
 676                 return ((*pru->pru_disconnect)(so));
 677         }
 678
 679         if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))
 680                 return ENOTCONN;
 681
 682         s = splnet();
 683         in6_pcbdisconnect(inp);
 684         inp->in6p_laddr = in6addr_any;
 685         splx(s);
 686         so->so_state &= ~SS_ISCONNECTED;                /* XXX */
 687         return 0;
 688 }
 689
 690 static int
 691 udp6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 692           struct mbuf *control, struct proc *p)
 693 {
 694         struct inpcb *inp;
 695         int error = 0;
 696
 697         inp = sotoinpcb(so);
 698         if (inp == 0) {
 699                 error = EINVAL;
 700                 goto bad;
 701         }
 702
 703         if (addr) {
 704                 if (addr->sa_len != sizeof(struct sockaddr_in6)) {
 705                         error = EINVAL;
 706                         goto bad;
 707                 }
 708                 if (addr->sa_family != AF_INET6) {
 709                         error = EAFNOSUPPORT;
 710                         goto bad;
 711                 }
 712         }
 713
 714         if (ip6_mapped_addr_on) {
 715                 int hasv4addr;
 716                 struct sockaddr_in6 *sin6 = 0;
 717
 718                 if (addr == 0)
 719                         hasv4addr = (inp->inp_vflag & INP_IPV4);
 720                 else {
 721                         sin6 = (struct sockaddr_in6 *)addr;
 722                         hasv4addr = IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)
 723                                 ? 1 : 0;
 724                 }
 725                 if (hasv4addr) {
 726                         struct pr_usrreqs *pru;
 727
 728                         if (sin6)
 729                                 in6_sin6_2_sin_in_sock(addr);
 730                         pru = ip_protox[IPPROTO_UDP]->pr_usrreqs;
 731                         error = ((*pru->pru_send)(so, flags, m, addr, control,
 732                                                   p));
 733                         /* addr will just be freed in sendit(). */
 734                         return error;
 735                 }
 736         }
 737
 738         return udp6_output(inp, m, addr, control, p);
 739
 740   bad:
 741         m_freem(m);
 742         return(error);
 743 }
 744
 745 struct pr_usrreqs udp6_usrreqs = {
 746         udp6_abort, pru_accept_notsupp, udp6_attach, udp6_bind, udp6_connect,
 747         pru_connect2_notsupp, in6_control, udp6_detach, udp6_disconnect,
 748         pru_listen_notsupp, in6_mapped_peeraddr, pru_rcvd_notsupp,
 749         pru_rcvoob_notsupp, udp6_send, pru_sense_null, udp_shutdown,
 750         in6_mapped_sockaddr, sosend, soreceive, sopoll
 751 };