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