sys/netinet6/raw_ip6.c

   1 /*
   2  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   3  * 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  * 3. Neither the name of the project 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 PROJECT 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 PROJECT 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  * $FreeBSD: src/sys/netinet6/raw_ip6.c,v 1.7.2.7 2003/01/24 05:11:35 sam Exp $
  30  * $DragonFly: src/sys/netinet6/raw_ip6.c,v 1.8 2003/08/23 11:02:46 rob Exp $
  31  */
  32
  33 /*
  34  * Copyright (c) 1982, 1986, 1988, 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  *      @(#)raw_ip.c    8.2 (Berkeley) 1/4/94
  66  */
  67
  68 #include "opt_ipsec.h"
  69 #include "opt_inet6.h"
  70
  71 #include <sys/param.h>
  72 #include <sys/malloc.h>
  73 #include <sys/proc.h>
  74 #include <sys/mbuf.h>
  75 #include <sys/socket.h>
  76 #include <sys/protosw.h>
  77 #include <sys/socketvar.h>
  78 #include <sys/errno.h>
  79 #include <sys/systm.h>
  80
  81 #include <net/if.h>
  82 #include <net/route.h>
  83 #include <net/if_types.h>
  84
  85 #include <netinet/in.h>
  86 #include <netinet/in_var.h>
  87 #include <netinet/in_systm.h>
  88 #include <netinet/ip6.h>
  89 #include <netinet6/ip6_var.h>
  90 #include <netinet6/ip6_mroute.h>
  91 #include <netinet/icmp6.h>
  92 #include <netinet/in_pcb.h>
  93 #include <netinet6/in6_pcb.h>
  94 #include <netinet6/nd6.h>
  95 #include <netinet6/ip6protosw.h>
  96 #ifdef ENABLE_DEFAULT_SCOPE
  97 #include <netinet6/scope6_var.h>
  98 #endif
  99 #include <netinet6/raw_ip6.h>
 100
 101 #ifdef IPSEC
 102 #include <netinet6/ipsec.h>
 103 #include <netinet6/ipsec6.h>
 104 #endif /*IPSEC*/
 105
 106 #ifdef FAST_IPSEC
 107 #include "ipsec.h"
 108 #include "ipsec6.h"
 109 #endif /* FAST_IPSEC */
 110
 111 #include <machine/stdarg.h>
 112
 113 #define satosin6(sa)    ((struct sockaddr_in6 *)(sa))
 114 #define ifatoia6(ifa)   ((struct in6_ifaddr *)(ifa))
 115
 116 /*
 117  * Raw interface to IP6 protocol.
 118  */
 119
 120 extern struct   inpcbhead ripcb;
 121 extern struct   inpcbinfo ripcbinfo;
 122 extern u_long   rip_sendspace;
 123 extern u_long   rip_recvspace;
 124
 125 struct rip6stat rip6stat;
 126
 127 /*
 128  * Setup generic address and protocol structures
 129  * for raw_input routine, then pass them along with
 130  * mbuf chain.
 131  */
 132 int
 133 rip6_input(mp, offp, proto)
 134         struct  mbuf **mp;
 135         int     *offp, proto;
 136 {
 137         struct mbuf *m = *mp;
 138         struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
 139         struct inpcb *in6p;
 140         struct inpcb *last = 0;
 141         struct mbuf *opts = NULL;
 142         struct sockaddr_in6 rip6src;
 143
 144         rip6stat.rip6s_ipackets++;
 145
 146         if (faithprefix_p != NULL && (*faithprefix_p)(&ip6->ip6_dst)) {
 147                 /* XXX send icmp6 host/port unreach? */
 148                 m_freem(m);
 149                 return IPPROTO_DONE;
 150         }
 151
 152         init_sin6(&rip6src, m); /* general init */
 153
 154         LIST_FOREACH(in6p, &ripcb, inp_list) {
 155                 if ((in6p->in6p_vflag & INP_IPV6) == 0)
 156                         continue;
 157                 if (in6p->in6p_ip6_nxt &&
 158                     in6p->in6p_ip6_nxt != proto)
 159                         continue;
 160                 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) &&
 161                     !IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &ip6->ip6_dst))
 162                         continue;
 163                 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr) &&
 164                     !IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, &ip6->ip6_src))
 165                         continue;
 166                 if (in6p->in6p_cksum != -1) {
 167                         rip6stat.rip6s_isum++;
 168                         if (in6_cksum(m, ip6->ip6_nxt, *offp,
 169                             m->m_pkthdr.len - *offp)) {
 170                                 rip6stat.rip6s_badsum++;
 171                                 continue;
 172                         }
 173                 }
 174                 if (last) {
 175                         struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
 176
 177 #ifdef IPSEC
 178                         /*
 179                          * Check AH/ESP integrity.
 180                          */
 181                         if (n && ipsec6_in_reject_so(n, last->inp_socket)) {
 182                                 m_freem(n);
 183                                 ipsec6stat.in_polvio++;
 184                                 /* do not inject data into pcb */
 185                         } else
 186 #endif /*IPSEC*/
 187 #ifdef FAST_IPSEC
 188                         /*
 189                          * Check AH/ESP integrity.
 190                          */
 191                         if (n && ipsec6_in_reject(n, last)) {
 192                                 m_freem(n);
 193                                 /* do not inject data into pcb */
 194                         } else
 195 #endif /*FAST_IPSEC*/
 196                         if (n) {
 197                                 if (last->in6p_flags & IN6P_CONTROLOPTS ||
 198                                     last->in6p_socket->so_options & SO_TIMESTAMP)
 199                                         ip6_savecontrol(last, &opts, ip6, n);
 200                                 /* strip intermediate headers */
 201                                 m_adj(n, *offp);
 202                                 if (sbappendaddr(&last->in6p_socket->so_rcv,
 203                                                 (struct sockaddr *)&rip6src,
 204                                                  n, opts) == 0) {
 205                                         m_freem(n);
 206                                         if (opts)
 207                                                 m_freem(opts);
 208                                         rip6stat.rip6s_fullsock++;
 209                                 } else
 210                                         sorwakeup(last->in6p_socket);
 211                                 opts = NULL;
 212                         }
 213                 }
 214                 last = in6p;
 215         }
 216 #ifdef IPSEC
 217         /*
 218          * Check AH/ESP integrity.
 219          */
 220         if (last && ipsec6_in_reject_so(m, last->inp_socket)) {
 221                 m_freem(m);
 222                 ipsec6stat.in_polvio++;
 223                 ip6stat.ip6s_delivered--;
 224                 /* do not inject data into pcb */
 225         } else
 226 #endif /*IPSEC*/
 227 #ifdef FAST_IPSEC
 228         /*
 229          * Check AH/ESP integrity.
 230          */
 231         if (last && ipsec6_in_reject(m, last)) {
 232                 m_freem(m);
 233                 ip6stat.ip6s_delivered--;
 234                 /* do not inject data into pcb */
 235         } else
 236 #endif /*FAST_IPSEC*/
 237         if (last) {
 238                 if (last->in6p_flags & IN6P_CONTROLOPTS ||
 239                     last->in6p_socket->so_options & SO_TIMESTAMP)
 240                         ip6_savecontrol(last, &opts, ip6, m);
 241                 /* strip intermediate headers */
 242                 m_adj(m, *offp);
 243                 if (sbappendaddr(&last->in6p_socket->so_rcv,
 244                                 (struct sockaddr *)&rip6src, m, opts) == 0) {
 245                         m_freem(m);
 246                         if (opts)
 247                                 m_freem(opts);
 248                         rip6stat.rip6s_fullsock++;
 249                 } else
 250                         sorwakeup(last->in6p_socket);
 251         } else {
 252                 rip6stat.rip6s_nosock++;
 253                 if (m->m_flags & M_MCAST)
 254                         rip6stat.rip6s_nosockmcast++;
 255                 if (proto == IPPROTO_NONE)
 256                         m_freem(m);
 257                 else {
 258                         char *prvnxtp = ip6_get_prevhdr(m, *offp); /* XXX */
 259                         icmp6_error(m, ICMP6_PARAM_PROB,
 260                                     ICMP6_PARAMPROB_NEXTHEADER,
 261                                     prvnxtp - mtod(m, char *));
 262                 }
 263                 ip6stat.ip6s_delivered--;
 264         }
 265         return IPPROTO_DONE;
 266 }
 267
 268 void
 269 rip6_ctlinput(cmd, sa, d)
 270         int cmd;
 271         struct sockaddr *sa;
 272         void *d;
 273 {
 274         struct ip6_hdr *ip6;
 275         struct mbuf *m;
 276         int off = 0;
 277         struct ip6ctlparam *ip6cp = NULL;
 278         const struct sockaddr_in6 *sa6_src = NULL;
 279         void (*notify) (struct inpcb *, int) = in6_rtchange;
 280
 281         if (sa->sa_family != AF_INET6 ||
 282             sa->sa_len != sizeof(struct sockaddr_in6))
 283                 return;
 284
 285         if ((unsigned)cmd >= PRC_NCMDS)
 286                 return;
 287         if (PRC_IS_REDIRECT(cmd))
 288                 notify = in6_rtchange, d = NULL;
 289         else if (cmd == PRC_HOSTDEAD)
 290                 d = NULL;
 291         else if (inet6ctlerrmap[cmd] == 0)
 292                 return;
 293
 294         /* if the parameter is from icmp6, decode it. */
 295         if (d != NULL) {
 296                 ip6cp = (struct ip6ctlparam *)d;
 297                 m = ip6cp->ip6c_m;
 298                 ip6 = ip6cp->ip6c_ip6;
 299                 off = ip6cp->ip6c_off;
 300                 sa6_src = ip6cp->ip6c_src;
 301         } else {
 302                 m = NULL;
 303                 ip6 = NULL;
 304                 sa6_src = &sa6_any;
 305         }
 306
 307         (void) in6_pcbnotify(&ripcb, sa, 0, (const struct sockaddr *)sa6_src,
 308                              0, cmd, notify);
 309 }
 310
 311 /*
 312  * Generate IPv6 header and pass packet to ip6_output.
 313  * Tack on options user may have setup with control call.
 314  */
 315 int
 316 #if __STDC__
 317 rip6_output(struct mbuf *m, ...)
 318 #else
 319 rip6_output(m, va_alist)
 320         struct mbuf *m;
 321         va_dcl
 322 #endif
 323 {
 324         struct socket *so;
 325         struct sockaddr_in6 *dstsock;
 326         struct mbuf *control;
 327         struct in6_addr *dst;
 328         struct ip6_hdr *ip6;
 329         struct inpcb *in6p;
 330         u_int   plen = m->m_pkthdr.len;
 331         int error = 0;
 332         struct ip6_pktopts opt, *optp = 0;
 333         struct ifnet *oifp = NULL;
 334         int type = 0, code = 0;         /* for ICMPv6 output statistics only */
 335         int priv = 0;
 336         va_list ap;
 337
 338         va_start(ap, m);
 339         so = va_arg(ap, struct socket *);
 340         dstsock = va_arg(ap, struct sockaddr_in6 *);
 341         control = va_arg(ap, struct mbuf *);
 342         va_end(ap);
 343
 344         in6p = sotoin6pcb(so);
 345
 346         priv = 0;
 347         if (so->so_cred->cr_uid == 0)
 348                 priv = 1;
 349         dst = &dstsock->sin6_addr;
 350         if (control) {
 351                 if ((error = ip6_setpktoptions(control, &opt, priv, 0)) != 0)
 352                         goto bad;
 353                 optp = &opt;
 354         } else
 355                 optp = in6p->in6p_outputopts;
 356
 357         /*
 358          * For an ICMPv6 packet, we should know its type and code
 359          * to update statistics.
 360          */
 361         if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) {
 362                 struct icmp6_hdr *icmp6;
 363                 if (m->m_len < sizeof(struct icmp6_hdr) &&
 364                     (m = m_pullup(m, sizeof(struct icmp6_hdr))) == NULL) {
 365                         error = ENOBUFS;
 366                         goto bad;
 367                 }
 368                 icmp6 = mtod(m, struct icmp6_hdr *);
 369                 type = icmp6->icmp6_type;
 370                 code = icmp6->icmp6_code;
 371         }
 372
 373         M_PREPEND(m, sizeof(*ip6), M_WAIT);
 374         ip6 = mtod(m, struct ip6_hdr *);
 375
 376         /*
 377          * Next header might not be ICMP6 but use its pseudo header anyway.
 378          */
 379         ip6->ip6_dst = *dst;
 380
 381         /*
 382          * If the scope of the destination is link-local, embed the interface
 383          * index in the address.
 384          *
 385          * XXX advanced-api value overrides sin6_scope_id
 386          */
 387         if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst)) {
 388                 struct in6_pktinfo *pi;
 389
 390                 /*
 391                  * XXX Boundary check is assumed to be already done in
 392                  * ip6_setpktoptions().
 393                  */
 394                 if (optp && (pi = optp->ip6po_pktinfo) && pi->ipi6_ifindex) {
 395                         ip6->ip6_dst.s6_addr16[1] = htons(pi->ipi6_ifindex);
 396                         oifp = ifindex2ifnet[pi->ipi6_ifindex];
 397                 } else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
 398                          in6p->in6p_moptions &&
 399                          in6p->in6p_moptions->im6o_multicast_ifp) {
 400                         oifp = in6p->in6p_moptions->im6o_multicast_ifp;
 401                         ip6->ip6_dst.s6_addr16[1] = htons(oifp->if_index);
 402                 } else if (dstsock->sin6_scope_id) {
 403                         /* boundary check */
 404                         if (dstsock->sin6_scope_id < 0
 405                          || if_index < dstsock->sin6_scope_id) {
 406                                 error = ENXIO;  /* XXX EINVAL? */
 407                                 goto bad;
 408                         }
 409                         ip6->ip6_dst.s6_addr16[1]
 410                                 = htons(dstsock->sin6_scope_id & 0xffff);/*XXX*/
 411                 }
 412         }
 413
 414         /*
 415          * Source address selection.
 416          */
 417         {
 418                 struct in6_addr *in6a;
 419
 420                 if ((in6a = in6_selectsrc(dstsock, optp,
 421                                           in6p->in6p_moptions,
 422                                           &in6p->in6p_route,
 423                                           &in6p->in6p_laddr,
 424                                           &error)) == 0) {
 425                         if (error == 0)
 426                                 error = EADDRNOTAVAIL;
 427                         goto bad;
 428                 }
 429                 ip6->ip6_src = *in6a;
 430                 if (in6p->in6p_route.ro_rt)
 431                         oifp = ifindex2ifnet[in6p->in6p_route.ro_rt->rt_ifp->if_index];
 432         }
 433         ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |
 434                 (in6p->in6p_flowinfo & IPV6_FLOWINFO_MASK);
 435         ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |
 436                 (IPV6_VERSION & IPV6_VERSION_MASK);
 437         /* ip6_plen will be filled in ip6_output, so not fill it here. */
 438         ip6->ip6_nxt = in6p->in6p_ip6_nxt;
 439         ip6->ip6_hlim = in6_selecthlim(in6p, oifp);
 440
 441         if (so->so_proto->pr_protocol == IPPROTO_ICMPV6 ||
 442             in6p->in6p_cksum != -1) {
 443                 struct mbuf *n;
 444                 int off;
 445                 u_int16_t *p;
 446
 447                 /* compute checksum */
 448                 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6)
 449                         off = offsetof(struct icmp6_hdr, icmp6_cksum);
 450                 else
 451                         off = in6p->in6p_cksum;
 452                 if (plen < off + 1) {
 453                         error = EINVAL;
 454                         goto bad;
 455                 }
 456                 off += sizeof(struct ip6_hdr);
 457
 458                 n = m;
 459                 while (n && n->m_len <= off) {
 460                         off -= n->m_len;
 461                         n = n->m_next;
 462                 }
 463                 if (!n)
 464                         goto bad;
 465                 p = (u_int16_t *)(mtod(n, caddr_t) + off);
 466                 *p = 0;
 467                 *p = in6_cksum(m, ip6->ip6_nxt, sizeof(*ip6), plen);
 468         }
 469
 470         error = ip6_output(m, optp, &in6p->in6p_route, 0,
 471                            in6p->in6p_moptions, &oifp, in6p);
 472         if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) {
 473                 if (oifp)
 474                         icmp6_ifoutstat_inc(oifp, type, code);
 475                 icmp6stat.icp6s_outhist[type]++;
 476         } else
 477                 rip6stat.rip6s_opackets++;
 478
 479         goto freectl;
 480
 481  bad:
 482         if (m)
 483                 m_freem(m);
 484
 485  freectl:
 486         if (optp == &opt && optp->ip6po_rthdr && optp->ip6po_route.ro_rt)
 487                 RTFREE(optp->ip6po_route.ro_rt);
 488         if (control) {
 489                 if (optp == &opt)
 490                         ip6_clearpktopts(optp, 0, -1);
 491                 m_freem(control);
 492         }
 493         return(error);
 494 }
 495
 496 /*
 497  * Raw IPv6 socket option processing.
 498  */
 499 int
 500 rip6_ctloutput(so, sopt)
 501         struct socket *so;
 502         struct sockopt *sopt;
 503 {
 504         int error;
 505
 506         if (sopt->sopt_level == IPPROTO_ICMPV6)
 507                 /*
 508                  * XXX: is it better to call icmp6_ctloutput() directly
 509                  * from protosw?
 510                  */
 511                 return(icmp6_ctloutput(so, sopt));
 512         else if (sopt->sopt_level != IPPROTO_IPV6)
 513                 return (EINVAL);
 514
 515         error = 0;
 516
 517         switch (sopt->sopt_dir) {
 518         case SOPT_GET:
 519                 switch (sopt->sopt_name) {
 520                 case MRT6_INIT:
 521                 case MRT6_DONE:
 522                 case MRT6_ADD_MIF:
 523                 case MRT6_DEL_MIF:
 524                 case MRT6_ADD_MFC:
 525                 case MRT6_DEL_MFC:
 526                 case MRT6_PIM:
 527                         error = ip6_mrouter_get(so, sopt);
 528                         break;
 529                 default:
 530                         error = ip6_ctloutput(so, sopt);
 531                         break;
 532                 }
 533                 break;
 534
 535         case SOPT_SET:
 536                 switch (sopt->sopt_name) {
 537                 case MRT6_INIT:
 538                 case MRT6_DONE:
 539                 case MRT6_ADD_MIF:
 540                 case MRT6_DEL_MIF:
 541                 case MRT6_ADD_MFC:
 542                 case MRT6_DEL_MFC:
 543                 case MRT6_PIM:
 544                         error = ip6_mrouter_set(so, sopt);
 545                         break;
 546                 default:
 547                         error = ip6_ctloutput(so, sopt);
 548                         break;
 549                 }
 550                 break;
 551         }
 552
 553         return (error);
 554 }
 555
 556 static int
 557 rip6_attach(struct socket *so, int proto, struct thread *td)
 558 {
 559         struct inpcb *inp;
 560         int error, s;
 561
 562         inp = sotoinpcb(so);
 563         if (inp)
 564                 panic("rip6_attach");
 565         if ((error = suser(td)) != 0)
 566                 return error;
 567
 568         error = soreserve(so, rip_sendspace, rip_recvspace);
 569         if (error)
 570                 return error;
 571         s = splnet();
 572         error = in_pcballoc(so, &ripcbinfo, td);
 573         splx(s);
 574         if (error)
 575                 return error;
 576         inp = (struct inpcb *)so->so_pcb;
 577         inp->inp_vflag |= INP_IPV6;
 578         inp->in6p_ip6_nxt = (long)proto;
 579         inp->in6p_hops = -1;    /* use kernel default */
 580         inp->in6p_cksum = -1;
 581         MALLOC(inp->in6p_icmp6filt, struct icmp6_filter *,
 582                sizeof(struct icmp6_filter), M_PCB, M_NOWAIT);
 583         ICMP6_FILTER_SETPASSALL(inp->in6p_icmp6filt);
 584         return 0;
 585 }
 586
 587 static int
 588 rip6_detach(struct socket *so)
 589 {
 590         struct inpcb *inp;
 591
 592         inp = sotoinpcb(so);
 593         if (inp == 0)
 594                 panic("rip6_detach");
 595         /* xxx: RSVP */
 596         if (so == ip6_mrouter)
 597                 ip6_mrouter_done();
 598         if (inp->in6p_icmp6filt) {
 599                 FREE(inp->in6p_icmp6filt, M_PCB);
 600                 inp->in6p_icmp6filt = NULL;
 601         }
 602         in6_pcbdetach(inp);
 603         return 0;
 604 }
 605
 606 static int
 607 rip6_abort(struct socket *so)
 608 {
 609         soisdisconnected(so);
 610         return rip6_detach(so);
 611 }
 612
 613 static int
 614 rip6_disconnect(struct socket *so)
 615 {
 616         struct inpcb *inp = sotoinpcb(so);
 617
 618         if ((so->so_state & SS_ISCONNECTED) == 0)
 619                 return ENOTCONN;
 620         inp->in6p_faddr = in6addr_any;
 621         return rip6_abort(so);
 622 }
 623
 624 static int
 625 rip6_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
 626 {
 627         struct inpcb *inp = sotoinpcb(so);
 628         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam;
 629         struct ifaddr *ia = NULL;
 630
 631         if (nam->sa_len != sizeof(*addr))
 632                 return EINVAL;
 633
 634         if (TAILQ_EMPTY(&ifnet) || addr->sin6_family != AF_INET6)
 635                 return EADDRNOTAVAIL;
 636 #ifdef ENABLE_DEFAULT_SCOPE
 637         if (addr->sin6_scope_id == 0) { /* not change if specified  */
 638                 addr->sin6_scope_id = scope6_addr2default(&addr->sin6_addr);
 639         }
 640 #endif
 641         if (!IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr) &&
 642             (ia = ifa_ifwithaddr((struct sockaddr *)addr)) == 0)
 643                 return EADDRNOTAVAIL;
 644         if (ia &&
 645             ((struct in6_ifaddr *)ia)->ia6_flags &
 646             (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY|
 647              IN6_IFF_DETACHED|IN6_IFF_DEPRECATED)) {
 648                 return(EADDRNOTAVAIL);
 649         }
 650         inp->in6p_laddr = addr->sin6_addr;
 651         return 0;
 652 }
 653
 654 static int
 655 rip6_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
 656 {
 657         struct inpcb *inp = sotoinpcb(so);
 658         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam;
 659         struct in6_addr *in6a = NULL;
 660         int error = 0;
 661 #ifdef ENABLE_DEFAULT_SCOPE
 662         struct sockaddr_in6 tmp;
 663 #endif
 664
 665         if (nam->sa_len != sizeof(*addr))
 666                 return EINVAL;
 667         if (TAILQ_EMPTY(&ifnet))
 668                 return EADDRNOTAVAIL;
 669         if (addr->sin6_family != AF_INET6)
 670                 return EAFNOSUPPORT;
 671 #ifdef ENABLE_DEFAULT_SCOPE
 672         if (addr->sin6_scope_id == 0) { /* not change if specified  */
 673                 /* avoid overwrites */
 674                 tmp = *addr;
 675                 addr = &tmp;
 676                 addr->sin6_scope_id = scope6_addr2default(&addr->sin6_addr);
 677         }
 678 #endif
 679         /* Source address selection. XXX: need pcblookup? */
 680         in6a = in6_selectsrc(addr, inp->in6p_outputopts,
 681                              inp->in6p_moptions, &inp->in6p_route,
 682                              &inp->in6p_laddr, &error);
 683         if (in6a == NULL)
 684                 return (error ? error : EADDRNOTAVAIL);
 685         inp->in6p_laddr = *in6a;
 686         inp->in6p_faddr = addr->sin6_addr;
 687         soisconnected(so);
 688         return 0;
 689 }
 690
 691 static int
 692 rip6_shutdown(struct socket *so)
 693 {
 694         socantsendmore(so);
 695         return 0;
 696 }
 697
 698 static int
 699 rip6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
 700          struct mbuf *control, struct thread *td)
 701 {
 702         struct inpcb *inp = sotoinpcb(so);
 703         struct sockaddr_in6 tmp;
 704         struct sockaddr_in6 *dst;
 705
 706         /* always copy sockaddr to avoid overwrites */
 707         if (so->so_state & SS_ISCONNECTED) {
 708                 if (nam) {
 709                         m_freem(m);
 710                         return EISCONN;
 711                 }
 712                 /* XXX */
 713                 bzero(&tmp, sizeof(tmp));
 714                 tmp.sin6_family = AF_INET6;
 715                 tmp.sin6_len = sizeof(struct sockaddr_in6);
 716                 bcopy(&inp->in6p_faddr, &tmp.sin6_addr,
 717                       sizeof(struct in6_addr));
 718                 dst = &tmp;
 719         } else {
 720                 if (nam == NULL) {
 721                         m_freem(m);
 722                         return ENOTCONN;
 723                 }
 724                 tmp = *(struct sockaddr_in6 *)nam;
 725                 dst = &tmp;
 726         }
 727 #ifdef ENABLE_DEFAULT_SCOPE
 728         if (dst->sin6_scope_id == 0) {  /* not change if specified  */
 729                 dst->sin6_scope_id = scope6_addr2default(&dst->sin6_addr);
 730         }
 731 #endif
 732         return rip6_output(m, so, dst, control);
 733 }
 734
 735 struct pr_usrreqs rip6_usrreqs = {
 736         rip6_abort, pru_accept_notsupp, rip6_attach, rip6_bind, rip6_connect,
 737         pru_connect2_notsupp, in6_control, rip6_detach, rip6_disconnect,
 738         pru_listen_notsupp, in6_setpeeraddr, pru_rcvd_notsupp,
 739         pru_rcvoob_notsupp, rip6_send, pru_sense_null, rip6_shutdown,
 740         in6_setsockaddr, sosend, soreceive, sopoll
 741 };