1 /* $NetBSD: udp6_usrreq.c,v 1.124 2016/07/15 07:40:09 ozaki-r Exp $ */
2 /* $KAME: udp6_usrreq.c,v 1.86 2001/05/27 17:33:00 itojun 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. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 * SUCH DAMAGE.
60 *
61 * @(#)udp_var.h 8.1 (Berkeley) 6/10/93
62 */
63
64 #include <sys/cdefs.h>
65 __KERNEL_RCSID(0, "$NetBSD: udp6_usrreq.c,v 1.124 2016/07/15 07:40:09 ozaki-r Exp $");
66
67 #ifdef _KERNEL_OPT
68 #include "opt_inet.h"
69 #include "opt_inet_csum.h"
70 #include "opt_ipsec.h"
71 #endif
72
73 #include <sys/param.h>
74 #include <sys/mbuf.h>
75 #include <sys/protosw.h>
76 #include <sys/socket.h>
77 #include <sys/socketvar.h>
78 #include <sys/systm.h>
79 #include <sys/proc.h>
80 #include <sys/syslog.h>
81 #include <sys/domain.h>
82 #include <sys/sysctl.h>
83
84 #include <net/if.h>
85 #include <net/if_types.h>
86
87 #include <netinet/in.h>
88 #include <netinet/in_var.h>
89 #include <netinet/in_systm.h>
90 #include <netinet/in_offload.h>
91 #include <netinet/ip.h>
92 #include <netinet/ip_var.h>
93 #include <netinet/in_pcb.h>
94 #include <netinet/udp.h>
95 #include <netinet/udp_var.h>
96 #include <netinet/udp_private.h>
97
98 #include <netinet/ip6.h>
99 #include <netinet/icmp6.h>
100 #include <netinet6/ip6_var.h>
101 #include <netinet6/ip6_private.h>
102 #include <netinet6/in6_pcb.h>
103 #include <netinet6/udp6_var.h>
104 #include <netinet6/udp6_private.h>
105 #include <netinet6/ip6protosw.h>
106 #include <netinet6/scope6_var.h>
107
108 #ifdef IPSEC
109 #include <netipsec/ipsec.h>
110 #include <netipsec/ipsec_var.h>
111 #include <netipsec/ipsec_private.h>
112 #ifdef INET6
113 #include <netipsec/ipsec6.h>
114 #endif
115 #endif /* IPSEC */
116
117 #include "faith.h"
118 #if defined(NFAITH) && NFAITH > 0
119 #include <net/if_faith.h>
120 #endif
121
122 /*
123 * UDP protocol implementation.
124 * Per RFC 768, August, 1980.
125 */
126
127 extern struct inpcbtable udbtable;
128
129 percpu_t *udp6stat_percpu;
130
131 /* UDP on IP6 parameters */
132 static int udp6_sendspace = 9216; /* really max datagram size */
133 static int udp6_recvspace = 40 * (1024 + sizeof(struct sockaddr_in6));
134 /* 40 1K datagrams */
135
136 static void udp6_notify(struct in6pcb *, int);
137 static void sysctl_net_inet6_udp6_setup(struct sysctllog **);
138
139 #ifdef UDP_CSUM_COUNTERS
140 #include <sys/device.h>
141 struct evcnt udp6_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
142 NULL, "udp6", "hwcsum bad");
143 struct evcnt udp6_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
144 NULL, "udp6", "hwcsum ok");
145 struct evcnt udp6_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
146 NULL, "udp6", "hwcsum data");
147 struct evcnt udp6_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
148 NULL, "udp6", "swcsum");
149
150 EVCNT_ATTACH_STATIC(udp6_hwcsum_bad);
151 EVCNT_ATTACH_STATIC(udp6_hwcsum_ok);
152 EVCNT_ATTACH_STATIC(udp6_hwcsum_data);
153 EVCNT_ATTACH_STATIC(udp6_swcsum);
154
155 #define UDP_CSUM_COUNTER_INCR(ev) (ev)->ev_count++
156 #else
157 #define UDP_CSUM_COUNTER_INCR(ev) /* nothing */
158 #endif
159
160 void
udp6_init(void)161 udp6_init(void)
162 {
163 sysctl_net_inet6_udp6_setup(NULL);
164 udp6stat_percpu = percpu_alloc(sizeof(uint64_t) * UDP6_NSTATS);
165
166 udp_init_common();
167 }
168
169 /*
170 * Notify a udp user of an asynchronous error;
171 * just wake up so that he can collect error status.
172 */
173 static void
udp6_notify(struct in6pcb * in6p,int errno)174 udp6_notify(struct in6pcb *in6p, int errno)
175 {
176 in6p->in6p_socket->so_error = errno;
177 sorwakeup(in6p->in6p_socket);
178 sowwakeup(in6p->in6p_socket);
179 }
180
181 void *
udp6_ctlinput(int cmd,const struct sockaddr * sa,void * d)182 udp6_ctlinput(int cmd, const struct sockaddr *sa, void *d)
183 {
184 struct udphdr uh;
185 struct ip6_hdr *ip6;
186 const struct sockaddr_in6 *sa6 = (const struct sockaddr_in6 *)sa;
187 struct mbuf *m;
188 int off;
189 void *cmdarg;
190 struct ip6ctlparam *ip6cp = NULL;
191 const struct sockaddr_in6 *sa6_src = NULL;
192 void (*notify)(struct in6pcb *, int) = udp6_notify;
193 struct udp_portonly {
194 u_int16_t uh_sport;
195 u_int16_t uh_dport;
196 } *uhp;
197
198 if (sa->sa_family != AF_INET6 ||
199 sa->sa_len != sizeof(struct sockaddr_in6))
200 return NULL;
201
202 if ((unsigned)cmd >= PRC_NCMDS)
203 return NULL;
204 if (PRC_IS_REDIRECT(cmd))
205 notify = in6_rtchange, d = NULL;
206 else if (cmd == PRC_HOSTDEAD)
207 d = NULL;
208 else if (cmd == PRC_MSGSIZE) {
209 /* special code is present, see below */
210 notify = in6_rtchange;
211 }
212 else if (inet6ctlerrmap[cmd] == 0)
213 return NULL;
214
215 /* if the parameter is from icmp6, decode it. */
216 if (d != NULL) {
217 ip6cp = (struct ip6ctlparam *)d;
218 m = ip6cp->ip6c_m;
219 ip6 = ip6cp->ip6c_ip6;
220 off = ip6cp->ip6c_off;
221 cmdarg = ip6cp->ip6c_cmdarg;
222 sa6_src = ip6cp->ip6c_src;
223 } else {
224 m = NULL;
225 ip6 = NULL;
226 cmdarg = NULL;
227 sa6_src = &sa6_any;
228 off = 0;
229 }
230
231 if (ip6) {
232 /*
233 * XXX: We assume that when IPV6 is non NULL,
234 * M and OFF are valid.
235 */
236
237 /* check if we can safely examine src and dst ports */
238 if (m->m_pkthdr.len < off + sizeof(*uhp)) {
239 if (cmd == PRC_MSGSIZE)
240 icmp6_mtudisc_update((struct ip6ctlparam *)d, 0);
241 return NULL;
242 }
243
244 memset(&uh, 0, sizeof(uh));
245 m_copydata(m, off, sizeof(*uhp), (void *)&uh);
246
247 if (cmd == PRC_MSGSIZE) {
248 int valid = 0;
249
250 /*
251 * Check to see if we have a valid UDP socket
252 * corresponding to the address in the ICMPv6 message
253 * payload.
254 */
255 if (in6_pcblookup_connect(&udbtable, &sa6->sin6_addr,
256 uh.uh_dport, (const struct in6_addr *)&sa6_src->sin6_addr,
257 uh.uh_sport, 0, 0))
258 valid++;
259 #if 0
260 /*
261 * As the use of sendto(2) is fairly popular,
262 * we may want to allow non-connected pcb too.
263 * But it could be too weak against attacks...
264 * We should at least check if the local address (= s)
265 * is really ours.
266 */
267 else if (in6_pcblookup_bind(&udbtable, &sa6->sin6_addr,
268 uh.uh_dport, 0))
269 valid++;
270 #endif
271
272 /*
273 * Depending on the value of "valid" and routing table
274 * size (mtudisc_{hi,lo}wat), we will:
275 * - recalculate the new MTU and create the
276 * corresponding routing entry, or
277 * - ignore the MTU change notification.
278 */
279 icmp6_mtudisc_update((struct ip6ctlparam *)d, valid);
280
281 /*
282 * regardless of if we called
283 * icmp6_mtudisc_update(), we need to call
284 * in6_pcbnotify(), to notify path MTU change
285 * to the userland (RFC3542), because some
286 * unconnected sockets may share the same
287 * destination and want to know the path MTU.
288 */
289 }
290
291 (void) in6_pcbnotify(&udbtable, sa, uh.uh_dport,
292 sin6tocsa(sa6_src), uh.uh_sport, cmd, cmdarg,
293 notify);
294 } else {
295 (void) in6_pcbnotify(&udbtable, sa, 0,
296 sin6tocsa(sa6_src), 0, cmd, cmdarg, notify);
297 }
298 return NULL;
299 }
300
301 int
udp6_ctloutput(int op,struct socket * so,struct sockopt * sopt)302 udp6_ctloutput(int op, struct socket *so, struct sockopt *sopt)
303 {
304 int s;
305 int error = 0;
306 int family;
307
308 family = so->so_proto->pr_domain->dom_family;
309
310 s = splsoftnet();
311 switch (family) {
312 #ifdef INET
313 case PF_INET:
314 if (sopt->sopt_level != IPPROTO_UDP) {
315 error = ip_ctloutput(op, so, sopt);
316 goto end;
317 }
318 break;
319 #endif
320 #ifdef INET6
321 case PF_INET6:
322 if (sopt->sopt_level != IPPROTO_UDP) {
323 error = ip6_ctloutput(op, so, sopt);
324 goto end;
325 }
326 break;
327 #endif
328 default:
329 error = EAFNOSUPPORT;
330 goto end;
331 }
332 error = EINVAL;
333
334 end:
335 splx(s);
336 return error;
337 }
338
339 static void
udp6_sendup(struct mbuf * m,int off,struct sockaddr * src,struct socket * so)340 udp6_sendup(struct mbuf *m, int off /* offset of data portion */,
341 struct sockaddr *src, struct socket *so)
342 {
343 struct mbuf *opts = NULL;
344 struct mbuf *n;
345 struct in6pcb *in6p = NULL;
346
347 if (!so)
348 return;
349 if (so->so_proto->pr_domain->dom_family != AF_INET6)
350 return;
351 in6p = sotoin6pcb(so);
352
353 #if defined(IPSEC)
354 /* check AH/ESP integrity. */
355 if (ipsec_used && so != NULL && ipsec6_in_reject_so(m, so)) {
356 IPSEC6_STATINC(IPSEC_STAT_IN_POLVIO);
357 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
358 icmp6_error(n, ICMP6_DST_UNREACH,
359 ICMP6_DST_UNREACH_ADMIN, 0);
360 return;
361 }
362 #endif /*IPSEC*/
363
364 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL) {
365 if (in6p && (in6p->in6p_flags & IN6P_CONTROLOPTS
366 #ifdef SO_OTIMESTAMP
367 || in6p->in6p_socket->so_options & SO_OTIMESTAMP
368 #endif
369 || in6p->in6p_socket->so_options & SO_TIMESTAMP)) {
370 struct ip6_hdr *ip6 = mtod(n, struct ip6_hdr *);
371 ip6_savecontrol(in6p, &opts, ip6, n);
372 }
373
374 m_adj(n, off);
375 if (sbappendaddr(&so->so_rcv, src, n, opts) == 0) {
376 m_freem(n);
377 if (opts)
378 m_freem(opts);
379 so->so_rcv.sb_overflowed++;
380 UDP6_STATINC(UDP6_STAT_FULLSOCK);
381 } else
382 sorwakeup(so);
383 }
384 }
385
386 int
udp6_realinput(int af,struct sockaddr_in6 * src,struct sockaddr_in6 * dst,struct mbuf * m,int off)387 udp6_realinput(int af, struct sockaddr_in6 *src, struct sockaddr_in6 *dst,
388 struct mbuf *m, int off)
389 {
390 u_int16_t sport, dport;
391 int rcvcnt;
392 struct in6_addr src6, *dst6;
393 const struct in_addr *dst4;
394 struct inpcb_hdr *inph;
395 struct in6pcb *in6p;
396
397 rcvcnt = 0;
398 off += sizeof(struct udphdr); /* now, offset of payload */
399
400 if (af != AF_INET && af != AF_INET6)
401 goto bad;
402 if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)
403 goto bad;
404
405 src6 = src->sin6_addr;
406 if (sa6_recoverscope(src) != 0) {
407 /* XXX: should be impossible. */
408 goto bad;
409 }
410 sport = src->sin6_port;
411
412 dport = dst->sin6_port;
413 dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[12];
414 dst6 = &dst->sin6_addr;
415
416 if (IN6_IS_ADDR_MULTICAST(dst6) ||
417 (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {
418 /*
419 * Deliver a multicast or broadcast datagram to *all* sockets
420 * for which the local and remote addresses and ports match
421 * those of the incoming datagram. This allows more than
422 * one process to receive multi/broadcasts on the same port.
423 * (This really ought to be done for unicast datagrams as
424 * well, but that would cause problems with existing
425 * applications that open both address-specific sockets and
426 * a wildcard socket listening to the same port -- they would
427 * end up receiving duplicates of every unicast datagram.
428 * Those applications open the multiple sockets to overcome an
429 * inadequacy of the UDP socket interface, but for backwards
430 * compatibility we avoid the problem here rather than
431 * fixing the interface. Maybe 4.5BSD will remedy this?)
432 */
433
434 /*
435 * KAME note: traditionally we dropped udpiphdr from mbuf here.
436 * we need udpiphdr for IPsec processing so we do that later.
437 */
438 /*
439 * Locate pcb(s) for datagram.
440 */
441 TAILQ_FOREACH(inph, &udbtable.inpt_queue, inph_queue) {
442 in6p = (struct in6pcb *)inph;
443 if (in6p->in6p_af != AF_INET6)
444 continue;
445
446 if (in6p->in6p_lport != dport)
447 continue;
448 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {
449 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr,
450 dst6))
451 continue;
452 } else {
453 if (IN6_IS_ADDR_V4MAPPED(dst6) &&
454 (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
455 continue;
456 }
457 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
458 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr,
459 &src6) || in6p->in6p_fport != sport)
460 continue;
461 } else {
462 if (IN6_IS_ADDR_V4MAPPED(&src6) &&
463 (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
464 continue;
465 }
466
467 udp6_sendup(m, off, sin6tosa(src), in6p->in6p_socket);
468 rcvcnt++;
469
470 /*
471 * Don't look for additional matches if this one does
472 * not have either the SO_REUSEPORT or SO_REUSEADDR
473 * socket options set. This heuristic avoids searching
474 * through all pcbs in the common case of a non-shared
475 * port. It assumes that an application will never
476 * clear these options after setting them.
477 */
478 if ((in6p->in6p_socket->so_options &
479 (SO_REUSEPORT|SO_REUSEADDR)) == 0)
480 break;
481 }
482 } else {
483 /*
484 * Locate pcb for datagram.
485 */
486 in6p = in6_pcblookup_connect(&udbtable, &src6, sport, dst6,
487 dport, 0, 0);
488 if (in6p == 0) {
489 UDP_STATINC(UDP_STAT_PCBHASHMISS);
490 in6p = in6_pcblookup_bind(&udbtable, dst6, dport, 0);
491 if (in6p == 0)
492 return rcvcnt;
493 }
494
495 udp6_sendup(m, off, sin6tosa(src), in6p->in6p_socket);
496 rcvcnt++;
497 }
498
499 bad:
500 return rcvcnt;
501 }
502
503 int
udp6_input_checksum(struct mbuf * m,const struct udphdr * uh,int off,int len)504 udp6_input_checksum(struct mbuf *m, const struct udphdr *uh, int off, int len)
505 {
506
507 /*
508 * XXX it's better to record and check if this mbuf is
509 * already checked.
510 */
511
512 if (__predict_false((m->m_flags & M_LOOP) && !udp_do_loopback_cksum)) {
513 goto good;
514 }
515 if (uh->uh_sum == 0) {
516 UDP6_STATINC(UDP6_STAT_NOSUM);
517 goto bad;
518 }
519
520 switch (m->m_pkthdr.csum_flags &
521 ((m_get_rcvif_NOMPSAFE(m)->if_csum_flags_rx & M_CSUM_UDPv6) |
522 M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
523 case M_CSUM_UDPv6|M_CSUM_TCP_UDP_BAD:
524 UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_bad);
525 UDP6_STATINC(UDP6_STAT_BADSUM);
526 goto bad;
527
528 #if 0 /* notyet */
529 case M_CSUM_UDPv6|M_CSUM_DATA:
530 #endif
531
532 case M_CSUM_UDPv6:
533 /* Checksum was okay. */
534 UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_ok);
535 break;
536
537 default:
538 /*
539 * Need to compute it ourselves. Maybe skip checksum
540 * on loopback interfaces.
541 */
542 UDP_CSUM_COUNTER_INCR(&udp6_swcsum);
543 if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {
544 UDP6_STATINC(UDP6_STAT_BADSUM);
545 goto bad;
546 }
547 }
548
549 good:
550 return 0;
551 bad:
552 return -1;
553 }
554
555 int
udp6_input(struct mbuf ** mp,int * offp,int proto)556 udp6_input(struct mbuf **mp, int *offp, int proto)
557 {
558 struct mbuf *m = *mp;
559 int off = *offp;
560 struct sockaddr_in6 src, dst;
561 struct ip6_hdr *ip6;
562 struct udphdr *uh;
563 u_int32_t plen, ulen;
564
565 ip6 = mtod(m, struct ip6_hdr *);
566
567 #if defined(NFAITH) && 0 < NFAITH
568 if (faithprefix(&ip6->ip6_dst)) {
569 /* send icmp6 host unreach? */
570 m_freem(m);
571 return IPPROTO_DONE;
572 }
573 #endif
574
575 UDP6_STATINC(UDP6_STAT_IPACKETS);
576
577 /* check for jumbogram is done in ip6_input. we can trust pkthdr.len */
578 plen = m->m_pkthdr.len - off;
579 IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));
580 if (uh == NULL) {
581 IP6_STATINC(IP6_STAT_TOOSHORT);
582 return IPPROTO_DONE;
583 }
584 KASSERT(UDP_HDR_ALIGNED_P(uh));
585 ulen = ntohs((u_short)uh->uh_ulen);
586 /*
587 * RFC2675 section 4: jumbograms will have 0 in the UDP header field,
588 * iff payload length > 0xffff.
589 */
590 if (ulen == 0 && plen > 0xffff)
591 ulen = plen;
592
593 if (plen != ulen) {
594 UDP6_STATINC(UDP6_STAT_BADLEN);
595 goto bad;
596 }
597
598 /* destination port of 0 is illegal, based on RFC768. */
599 if (uh->uh_dport == 0)
600 goto bad;
601
602 /* Be proactive about malicious use of IPv4 mapped address */
603 if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
604 IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
605 /* XXX stat */
606 goto bad;
607 }
608
609 /*
610 * Checksum extended UDP header and data. Maybe skip checksum
611 * on loopback interfaces.
612 */
613 if (udp6_input_checksum(m, uh, off, ulen))
614 goto bad;
615
616 /*
617 * Construct source and dst sockaddrs.
618 */
619 memset(&src, 0, sizeof(src));
620 src.sin6_family = AF_INET6;
621 src.sin6_len = sizeof(struct sockaddr_in6);
622 src.sin6_addr = ip6->ip6_src;
623 src.sin6_port = uh->uh_sport;
624 memset(&dst, 0, sizeof(dst));
625 dst.sin6_family = AF_INET6;
626 dst.sin6_len = sizeof(struct sockaddr_in6);
627 dst.sin6_addr = ip6->ip6_dst;
628 dst.sin6_port = uh->uh_dport;
629
630 if (udp6_realinput(AF_INET6, &src, &dst, m, off) == 0) {
631 if (m->m_flags & M_MCAST) {
632 UDP6_STATINC(UDP6_STAT_NOPORTMCAST);
633 goto bad;
634 }
635 UDP6_STATINC(UDP6_STAT_NOPORT);
636 icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
637 m = NULL;
638 }
639
640 bad:
641 if (m)
642 m_freem(m);
643 return IPPROTO_DONE;
644 }
645
646 static int
udp6_attach(struct socket * so,int proto)647 udp6_attach(struct socket *so, int proto)
648 {
649 struct in6pcb *in6p;
650 int s, error;
651
652 KASSERT(sotoin6pcb(so) == NULL);
653 sosetlock(so);
654
655 /*
656 * MAPPED_ADDR implementation spec:
657 * Always attach for IPv6, and only when necessary for IPv4.
658 */
659 s = splsoftnet();
660 error = in6_pcballoc(so, &udbtable);
661 splx(s);
662 if (error) {
663 return error;
664 }
665 error = soreserve(so, udp6_sendspace, udp6_recvspace);
666 if (error) {
667 return error;
668 }
669 in6p = sotoin6pcb(so);
670 in6p->in6p_cksum = -1; /* just to be sure */
671
672 KASSERT(solocked(so));
673 return 0;
674 }
675
676 static void
udp6_detach(struct socket * so)677 udp6_detach(struct socket *so)
678 {
679 struct in6pcb *in6p = sotoin6pcb(so);
680 int s;
681
682 KASSERT(solocked(so));
683 KASSERT(in6p != NULL);
684
685 s = splsoftnet();
686 in6_pcbdetach(in6p);
687 splx(s);
688 }
689
690 static int
udp6_accept(struct socket * so,struct sockaddr * nam)691 udp6_accept(struct socket *so, struct sockaddr *nam)
692 {
693 KASSERT(solocked(so));
694
695 return EOPNOTSUPP;
696 }
697
698 static int
udp6_bind(struct socket * so,struct sockaddr * nam,struct lwp * l)699 udp6_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
700 {
701 struct in6pcb *in6p = sotoin6pcb(so);
702 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
703 int error = 0;
704 int s;
705
706 KASSERT(solocked(so));
707 KASSERT(in6p != NULL);
708
709 s = splsoftnet();
710 error = in6_pcbbind(in6p, sin6, l);
711 splx(s);
712 return error;
713 }
714
715 static int
udp6_listen(struct socket * so,struct lwp * l)716 udp6_listen(struct socket *so, struct lwp *l)
717 {
718 KASSERT(solocked(so));
719
720 return EOPNOTSUPP;
721 }
722
723 static int
udp6_connect(struct socket * so,struct sockaddr * nam,struct lwp * l)724 udp6_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
725 {
726 struct in6pcb *in6p = sotoin6pcb(so);
727 int error = 0;
728 int s;
729
730 KASSERT(solocked(so));
731 KASSERT(in6p != NULL);
732
733 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr))
734 return EISCONN;
735 s = splsoftnet();
736 error = in6_pcbconnect(in6p, (struct sockaddr_in6 *)nam, l);
737 splx(s);
738 if (error == 0)
739 soisconnected(so);
740
741 return error;
742 }
743
744 static int
udp6_connect2(struct socket * so,struct socket * so2)745 udp6_connect2(struct socket *so, struct socket *so2)
746 {
747 KASSERT(solocked(so));
748
749 return EOPNOTSUPP;
750 }
751
752 static int
udp6_disconnect(struct socket * so)753 udp6_disconnect(struct socket *so)
754 {
755 struct in6pcb *in6p = sotoin6pcb(so);
756 int s;
757
758 KASSERT(solocked(so));
759 KASSERT(in6p != NULL);
760
761 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr))
762 return ENOTCONN;
763
764 s = splsoftnet();
765 in6_pcbdisconnect(in6p);
766 memset((void *)&in6p->in6p_laddr, 0, sizeof(in6p->in6p_laddr));
767 splx(s);
768
769 so->so_state &= ~SS_ISCONNECTED; /* XXX */
770 in6_pcbstate(in6p, IN6P_BOUND); /* XXX */
771 return 0;
772 }
773
774 static int
udp6_shutdown(struct socket * so)775 udp6_shutdown(struct socket *so)
776 {
777 int s;
778
779 s = splsoftnet();
780 socantsendmore(so);
781 splx(s);
782
783 return 0;
784 }
785
786 static int
udp6_abort(struct socket * so)787 udp6_abort(struct socket *so)
788 {
789 int s;
790
791 KASSERT(solocked(so));
792 KASSERT(sotoin6pcb(so) != NULL);
793
794 s = splsoftnet();
795 soisdisconnected(so);
796 in6_pcbdetach(sotoin6pcb(so));
797 splx(s);
798
799 return 0;
800 }
801
802 static int
udp6_ioctl(struct socket * so,u_long cmd,void * addr6,struct ifnet * ifp)803 udp6_ioctl(struct socket *so, u_long cmd, void *addr6, struct ifnet *ifp)
804 {
805 /*
806 * MAPPED_ADDR implementation info:
807 * Mapped addr support for PRU_CONTROL is not necessary.
808 * Because typical user of PRU_CONTROL is such as ifconfig,
809 * and they don't associate any addr to their socket. Then
810 * socket family is only hint about the PRU_CONTROL'ed address
811 * family, especially when getting addrs from kernel.
812 * So AF_INET socket need to be used to control AF_INET addrs,
813 * and AF_INET6 socket for AF_INET6 addrs.
814 */
815 return in6_control(so, cmd, addr6, ifp);
816 }
817
818 static int
udp6_stat(struct socket * so,struct stat * ub)819 udp6_stat(struct socket *so, struct stat *ub)
820 {
821 KASSERT(solocked(so));
822
823 /* stat: don't bother with a blocksize */
824 return 0;
825 }
826
827 static int
udp6_peeraddr(struct socket * so,struct sockaddr * nam)828 udp6_peeraddr(struct socket *so, struct sockaddr *nam)
829 {
830 KASSERT(solocked(so));
831 KASSERT(sotoin6pcb(so) != NULL);
832 KASSERT(nam != NULL);
833
834 in6_setpeeraddr(sotoin6pcb(so), (struct sockaddr_in6 *)nam);
835 return 0;
836 }
837
838 static int
udp6_sockaddr(struct socket * so,struct sockaddr * nam)839 udp6_sockaddr(struct socket *so, struct sockaddr *nam)
840 {
841 KASSERT(solocked(so));
842 KASSERT(sotoin6pcb(so) != NULL);
843 KASSERT(nam != NULL);
844
845 in6_setsockaddr(sotoin6pcb(so), (struct sockaddr_in6 *)nam);
846 return 0;
847 }
848
849 static int
udp6_rcvd(struct socket * so,int flags,struct lwp * l)850 udp6_rcvd(struct socket *so, int flags, struct lwp *l)
851 {
852 KASSERT(solocked(so));
853
854 return EOPNOTSUPP;
855 }
856
857 static int
udp6_recvoob(struct socket * so,struct mbuf * m,int flags)858 udp6_recvoob(struct socket *so, struct mbuf *m, int flags)
859 {
860 KASSERT(solocked(so));
861
862 return EOPNOTSUPP;
863 }
864
865 static int
udp6_send(struct socket * so,struct mbuf * m,struct sockaddr * nam,struct mbuf * control,struct lwp * l)866 udp6_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
867 struct mbuf *control, struct lwp *l)
868 {
869 struct in6pcb *in6p = sotoin6pcb(so);
870 int error = 0;
871 int s;
872
873 KASSERT(solocked(so));
874 KASSERT(in6p != NULL);
875 KASSERT(m != NULL);
876
877 s = splsoftnet();
878 error = udp6_output(in6p, m, (struct sockaddr_in6 *)nam, control, l);
879 splx(s);
880
881 return error;
882 }
883
884 static int
udp6_sendoob(struct socket * so,struct mbuf * m,struct mbuf * control)885 udp6_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
886 {
887 KASSERT(solocked(so));
888
889 if (m)
890 m_freem(m);
891 if (control)
892 m_freem(control);
893
894 return EOPNOTSUPP;
895 }
896
897 static int
udp6_purgeif(struct socket * so,struct ifnet * ifp)898 udp6_purgeif(struct socket *so, struct ifnet *ifp)
899 {
900
901 mutex_enter(softnet_lock);
902 in6_pcbpurgeif0(&udbtable, ifp);
903 in6_purgeif(ifp);
904 in6_pcbpurgeif(&udbtable, ifp);
905 mutex_exit(softnet_lock);
906
907 return 0;
908 }
909
910 static int
sysctl_net_inet6_udp6_stats(SYSCTLFN_ARGS)911 sysctl_net_inet6_udp6_stats(SYSCTLFN_ARGS)
912 {
913
914 return (NETSTAT_SYSCTL(udp6stat_percpu, UDP6_NSTATS));
915 }
916
917 static void
sysctl_net_inet6_udp6_setup(struct sysctllog ** clog)918 sysctl_net_inet6_udp6_setup(struct sysctllog **clog)
919 {
920
921 sysctl_createv(clog, 0, NULL, NULL,
922 CTLFLAG_PERMANENT,
923 CTLTYPE_NODE, "inet6", NULL,
924 NULL, 0, NULL, 0,
925 CTL_NET, PF_INET6, CTL_EOL);
926 sysctl_createv(clog, 0, NULL, NULL,
927 CTLFLAG_PERMANENT,
928 CTLTYPE_NODE, "udp6",
929 SYSCTL_DESCR("UDPv6 related settings"),
930 NULL, 0, NULL, 0,
931 CTL_NET, PF_INET6, IPPROTO_UDP, CTL_EOL);
932
933 sysctl_createv(clog, 0, NULL, NULL,
934 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
935 CTLTYPE_INT, "sendspace",
936 SYSCTL_DESCR("Default UDP send buffer size"),
937 NULL, 0, &udp6_sendspace, 0,
938 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_SENDSPACE,
939 CTL_EOL);
940 sysctl_createv(clog, 0, NULL, NULL,
941 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
942 CTLTYPE_INT, "recvspace",
943 SYSCTL_DESCR("Default UDP receive buffer size"),
944 NULL, 0, &udp6_recvspace, 0,
945 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_RECVSPACE,
946 CTL_EOL);
947 sysctl_createv(clog, 0, NULL, NULL,
948 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
949 CTLTYPE_INT, "do_loopback_cksum",
950 SYSCTL_DESCR("Perform UDP checksum on loopback"),
951 NULL, 0, &udp_do_loopback_cksum, 0,
952 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_LOOPBACKCKSUM,
953 CTL_EOL);
954 sysctl_createv(clog, 0, NULL, NULL,
955 CTLFLAG_PERMANENT,
956 CTLTYPE_STRUCT, "pcblist",
957 SYSCTL_DESCR("UDP protocol control block list"),
958 sysctl_inpcblist, 0, &udbtable, 0,
959 CTL_NET, PF_INET6, IPPROTO_UDP, CTL_CREATE,
960 CTL_EOL);
961 sysctl_createv(clog, 0, NULL, NULL,
962 CTLFLAG_PERMANENT,
963 CTLTYPE_STRUCT, "stats",
964 SYSCTL_DESCR("UDPv6 statistics"),
965 sysctl_net_inet6_udp6_stats, 0, NULL, 0,
966 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_STATS,
967 CTL_EOL);
968 }
969
970 void
udp6_statinc(u_int stat)971 udp6_statinc(u_int stat)
972 {
973
974 KASSERT(stat < UDP6_NSTATS);
975 UDP6_STATINC(stat);
976 }
977
978 PR_WRAP_USRREQS(udp6)
979 #define udp6_attach udp6_attach_wrapper
980 #define udp6_detach udp6_detach_wrapper
981 #define udp6_accept udp6_accept_wrapper
982 #define udp6_bind udp6_bind_wrapper
983 #define udp6_listen udp6_listen_wrapper
984 #define udp6_connect udp6_connect_wrapper
985 #define udp6_connect2 udp6_connect2_wrapper
986 #define udp6_disconnect udp6_disconnect_wrapper
987 #define udp6_shutdown udp6_shutdown_wrapper
988 #define udp6_abort udp6_abort_wrapper
989 #define udp6_ioctl udp6_ioctl_wrapper
990 #define udp6_stat udp6_stat_wrapper
991 #define udp6_peeraddr udp6_peeraddr_wrapper
992 #define udp6_sockaddr udp6_sockaddr_wrapper
993 #define udp6_rcvd udp6_rcvd_wrapper
994 #define udp6_recvoob udp6_recvoob_wrapper
995 #define udp6_send udp6_send_wrapper
996 #define udp6_sendoob udp6_sendoob_wrapper
997 #define udp6_purgeif udp6_purgeif_wrapper
998
999 const struct pr_usrreqs udp6_usrreqs = {
1000 .pr_attach = udp6_attach,
1001 .pr_detach = udp6_detach,
1002 .pr_accept = udp6_accept,
1003 .pr_bind = udp6_bind,
1004 .pr_listen = udp6_listen,
1005 .pr_connect = udp6_connect,
1006 .pr_connect2 = udp6_connect2,
1007 .pr_disconnect = udp6_disconnect,
1008 .pr_shutdown = udp6_shutdown,
1009 .pr_abort = udp6_abort,
1010 .pr_ioctl = udp6_ioctl,
1011 .pr_stat = udp6_stat,
1012 .pr_peeraddr = udp6_peeraddr,
1013 .pr_sockaddr = udp6_sockaddr,
1014 .pr_rcvd = udp6_rcvd,
1015 .pr_recvoob = udp6_recvoob,
1016 .pr_send = udp6_send,
1017 .pr_sendoob = udp6_sendoob,
1018 .pr_purgeif = udp6_purgeif,
1019 };
1020