1 /* $NetBSD: udp6_usrreq.c,v 1.156 2024/10/08 02:30:05 riastradh Exp $ */
2 /* $KAME: udp6_usrreq.c,v 1.86 2001/05/27 17:33:00 itojun Exp $ */
3 /* $KAME: udp6_output.c,v 1.43 2001/10/15 09:19:52 itojun Exp $ */
4
5 /*
6 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the project nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 /*
35 * Copyright (c) 1982, 1986, 1989, 1993
36 * The Regents of the University of California. All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. Neither the name of the University nor the names of its contributors
47 * may be used to endorse or promote products derived from this software
48 * without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60 * SUCH DAMAGE.
61 *
62 * @(#)udp_var.h 8.1 (Berkeley) 6/10/93
63 */
64
65 #include <sys/cdefs.h>
66 __KERNEL_RCSID(0, "$NetBSD: udp6_usrreq.c,v 1.156 2024/10/08 02:30:05 riastradh Exp $");
67
68 #ifdef _KERNEL_OPT
69 #include "opt_inet.h"
70 #include "opt_inet_csum.h"
71 #include "opt_ipsec.h"
72 #include "opt_net_mpsafe.h"
73 #endif
74
75 #include <sys/param.h>
76 #include <sys/mbuf.h>
77 #include <sys/protosw.h>
78 #include <sys/socket.h>
79 #include <sys/socketvar.h>
80 #include <sys/systm.h>
81 #include <sys/proc.h>
82 #include <sys/syslog.h>
83 #include <sys/domain.h>
84 #include <sys/sysctl.h>
85
86 #include <net/if.h>
87 #include <net/if_types.h>
88
89 #include <netinet/in.h>
90 #include <netinet/in_var.h>
91 #include <netinet/in_systm.h>
92 #include <netinet/in_offload.h>
93 #include <netinet/ip.h>
94 #include <netinet/ip_var.h>
95 #include <netinet/in_pcb.h>
96 #include <netinet/udp.h>
97 #include <netinet/udp_var.h>
98 #include <netinet/udp_private.h>
99
100 #include <netinet/ip6.h>
101 #include <netinet/icmp6.h>
102 #include <netinet6/ip6_var.h>
103 #include <netinet6/ip6_private.h>
104 #include <netinet6/in6_pcb.h>
105 #include <netinet6/udp6_var.h>
106 #include <netinet6/udp6_private.h>
107 #include <netinet6/ip6protosw.h>
108 #include <netinet6/scope6_var.h>
109
110 #ifdef IPSEC
111 #include <netipsec/ipsec.h>
112 #include <netipsec/esp.h>
113 #ifdef INET6
114 #include <netipsec/ipsec6.h>
115 #endif
116 #endif
117
118 #include "faith.h"
119 #if defined(NFAITH) && NFAITH > 0
120 #include <net/if_faith.h>
121 #endif
122
123 /*
124 * UDP protocol implementation.
125 * Per RFC 768, August, 1980.
126 */
127
128 extern struct inpcbtable udbtable;
129
130 percpu_t *udp6stat_percpu;
131
132 /* UDP on IP6 parameters */
133 static int udp6_sendspace = 9216; /* really max datagram size */
134 static int udp6_recvspace = 40 * (1024 + sizeof(struct sockaddr_in6));
135 /* 40 1K datagrams */
136
137 static void udp6_notify(struct inpcb *, int);
138 static void sysctl_net_inet6_udp6_setup(struct sysctllog **);
139 #ifdef IPSEC
140 static int udp6_espinudp(struct mbuf **, int);
141 #endif
142
143 #ifdef UDP_CSUM_COUNTERS
144 #include <sys/device.h>
145 struct evcnt udp6_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
146 NULL, "udp6", "hwcsum bad");
147 struct evcnt udp6_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
148 NULL, "udp6", "hwcsum ok");
149 struct evcnt udp6_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
150 NULL, "udp6", "hwcsum data");
151 struct evcnt udp6_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
152 NULL, "udp6", "swcsum");
153
154 EVCNT_ATTACH_STATIC(udp6_hwcsum_bad);
155 EVCNT_ATTACH_STATIC(udp6_hwcsum_ok);
156 EVCNT_ATTACH_STATIC(udp6_hwcsum_data);
157 EVCNT_ATTACH_STATIC(udp6_swcsum);
158
159 #define UDP_CSUM_COUNTER_INCR(ev) (ev)->ev_count++
160 #else
161 #define UDP_CSUM_COUNTER_INCR(ev) /* nothing */
162 #endif
163
164 void
udp6_init(void)165 udp6_init(void)
166 {
167 sysctl_net_inet6_udp6_setup(NULL);
168 udp6stat_percpu = percpu_alloc(sizeof(uint64_t) * UDP6_NSTATS);
169
170 udp_init_common();
171 }
172
173 /*
174 * Notify a udp user of an asynchronous error;
175 * just wake up so that he can collect error status.
176 */
177 static void
udp6_notify(struct inpcb * inp,int errno)178 udp6_notify(struct inpcb *inp, int errno)
179 {
180 inp->inp_socket->so_error = errno;
181 sorwakeup(inp->inp_socket);
182 sowwakeup(inp->inp_socket);
183 }
184
185 void *
udp6_ctlinput(int cmd,const struct sockaddr * sa,void * d)186 udp6_ctlinput(int cmd, const struct sockaddr *sa, void *d)
187 {
188 struct udphdr uh;
189 struct ip6_hdr *ip6;
190 const struct sockaddr_in6 *sa6 = (const struct sockaddr_in6 *)sa;
191 struct mbuf *m;
192 int off;
193 void *cmdarg;
194 struct ip6ctlparam *ip6cp = NULL;
195 const struct sockaddr_in6 *sa6_src = NULL;
196 void (*notify)(struct inpcb *, int) = udp6_notify;
197 struct udp_portonly {
198 u_int16_t uh_sport;
199 u_int16_t uh_dport;
200 } *uhp;
201
202 if (sa->sa_family != AF_INET6 ||
203 sa->sa_len != sizeof(struct sockaddr_in6))
204 return NULL;
205
206 if ((unsigned)cmd >= PRC_NCMDS)
207 return NULL;
208 if (PRC_IS_REDIRECT(cmd))
209 notify = in6pcb_rtchange, d = NULL;
210 else if (cmd == PRC_HOSTDEAD)
211 d = NULL;
212 else if (cmd == PRC_MSGSIZE) {
213 /* special code is present, see below */
214 notify = in6pcb_rtchange;
215 }
216 else if (inet6ctlerrmap[cmd] == 0)
217 return NULL;
218
219 /* if the parameter is from icmp6, decode it. */
220 if (d != NULL) {
221 ip6cp = (struct ip6ctlparam *)d;
222 m = ip6cp->ip6c_m;
223 ip6 = ip6cp->ip6c_ip6;
224 off = ip6cp->ip6c_off;
225 cmdarg = ip6cp->ip6c_cmdarg;
226 sa6_src = ip6cp->ip6c_src;
227 } else {
228 m = NULL;
229 ip6 = NULL;
230 cmdarg = NULL;
231 sa6_src = &sa6_any;
232 off = 0;
233 }
234
235 if (ip6) {
236 /* check if we can safely examine src and dst ports */
237 if (m->m_pkthdr.len < off + sizeof(*uhp)) {
238 if (cmd == PRC_MSGSIZE)
239 icmp6_mtudisc_update((struct ip6ctlparam *)d, 0);
240 return NULL;
241 }
242
243 memset(&uh, 0, sizeof(uh));
244 m_copydata(m, off, sizeof(*uhp), (void *)&uh);
245
246 if (cmd == PRC_MSGSIZE) {
247 int valid = 0;
248
249 /*
250 * Check to see if we have a valid UDP socket
251 * corresponding to the address in the ICMPv6 message
252 * payload.
253 */
254 if (in6pcb_lookup(&udbtable, &sa6->sin6_addr,
255 uh.uh_dport, (const struct in6_addr *)&sa6_src->sin6_addr,
256 uh.uh_sport, 0, 0))
257 valid++;
258 #if 0
259 /*
260 * As the use of sendto(2) is fairly popular,
261 * we may want to allow non-connected pcb too.
262 * But it could be too weak against attacks...
263 * We should at least check if the local address (= s)
264 * is really ours.
265 */
266 else if (in6pcb_lookup_bound(&udbtable, &sa6->sin6_addr,
267 uh.uh_dport, 0))
268 valid++;
269 #endif
270
271 /*
272 * Depending on the value of "valid" and routing table
273 * size (mtudisc_{hi,lo}wat), we will:
274 * - recalculate the new MTU and create the
275 * corresponding routing entry, or
276 * - ignore the MTU change notification.
277 */
278 icmp6_mtudisc_update((struct ip6ctlparam *)d, valid);
279
280 /*
281 * regardless of if we called
282 * icmp6_mtudisc_update(), we need to call
283 * in6pcb_notify(), to notify path MTU change
284 * to the userland (RFC3542), because some
285 * unconnected sockets may share the same
286 * destination and want to know the path MTU.
287 */
288 }
289
290 (void)in6pcb_notify(&udbtable, sa, uh.uh_dport,
291 sin6tocsa(sa6_src), uh.uh_sport, cmd, cmdarg,
292 notify);
293 } else {
294 (void)in6pcb_notify(&udbtable, sa, 0,
295 sin6tocsa(sa6_src), 0, cmd, cmdarg, notify);
296 }
297 return NULL;
298 }
299
300 int
udp6_ctloutput(int op,struct socket * so,struct sockopt * sopt)301 udp6_ctloutput(int op, struct socket *so, struct sockopt *sopt)
302 {
303 int s;
304 int error = 0;
305 struct inpcb *inp;
306 int family;
307 int optval;
308
309 family = so->so_proto->pr_domain->dom_family;
310
311 s = splsoftnet();
312 switch (family) {
313 #ifdef INET
314 case PF_INET:
315 if (sopt->sopt_level != IPPROTO_UDP) {
316 error = ip_ctloutput(op, so, sopt);
317 goto end;
318 }
319 break;
320 #endif
321 #ifdef INET6
322 case PF_INET6:
323 if (sopt->sopt_level != IPPROTO_UDP) {
324 error = ip6_ctloutput(op, so, sopt);
325 goto end;
326 }
327 break;
328 #endif
329 default:
330 error = EAFNOSUPPORT;
331 goto end;
332 }
333
334 switch (op) {
335 case PRCO_SETOPT:
336 inp = sotoinpcb(so);
337
338 switch (sopt->sopt_name) {
339 case UDP_ENCAP:
340 error = sockopt_getint(sopt, &optval);
341 if (error)
342 break;
343
344 switch(optval) {
345 case 0:
346 inp->inp_flags &= ~IN6P_ESPINUDP;
347 break;
348
349 case UDP_ENCAP_ESPINUDP:
350 inp->inp_flags |= IN6P_ESPINUDP;
351 break;
352
353 default:
354 error = EINVAL;
355 break;
356 }
357 break;
358
359 default:
360 error = ENOPROTOOPT;
361 break;
362 }
363 break;
364
365 default:
366 error = EINVAL;
367 break;
368 }
369
370 end:
371 splx(s);
372 return error;
373 }
374
375 static void
udp6_sendup(struct mbuf * m,int off,struct sockaddr * src,struct socket * so)376 udp6_sendup(struct mbuf *m, int off /* offset of data portion */,
377 struct sockaddr *src, struct socket *so)
378 {
379 struct mbuf *opts = NULL;
380 struct mbuf *n;
381 struct inpcb *inp;
382
383 KASSERT(so != NULL);
384 KASSERT(so->so_proto->pr_domain->dom_family == AF_INET6);
385 inp = sotoinpcb(so);
386 KASSERT(inp != NULL);
387
388 #if defined(IPSEC)
389 if (ipsec_used && ipsec_in_reject(m, inp)) {
390 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
391 icmp6_error(n, ICMP6_DST_UNREACH,
392 ICMP6_DST_UNREACH_ADMIN, 0);
393 return;
394 }
395 #endif
396
397 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL) {
398 if (inp->inp_flags & IN6P_CONTROLOPTS ||
399 SOOPT_TIMESTAMP(inp->inp_socket->so_options)) {
400 struct ip6_hdr *ip6 = mtod(n, struct ip6_hdr *);
401 ip6_savecontrol(inp, &opts, ip6, n);
402 }
403
404 m_adj(n, off);
405 if (sbappendaddr(&so->so_rcv, src, n, opts) == 0) {
406 m_freem(n);
407 m_freem(opts);
408 UDP6_STATINC(UDP6_STAT_FULLSOCK);
409 soroverflow(so);
410 } else
411 sorwakeup(so);
412 }
413 }
414
415 int
udp6_realinput(int af,struct sockaddr_in6 * src,struct sockaddr_in6 * dst,struct mbuf ** mp,int off)416 udp6_realinput(int af, struct sockaddr_in6 *src, struct sockaddr_in6 *dst,
417 struct mbuf **mp, int off)
418 {
419 u_int16_t sport, dport;
420 int rcvcnt;
421 struct in6_addr src6, *dst6;
422 const struct in_addr *dst4;
423 struct inpcb *inp;
424 struct mbuf *m = *mp;
425
426 rcvcnt = 0;
427 off += sizeof(struct udphdr); /* now, offset of payload */
428
429 if (af != AF_INET && af != AF_INET6)
430 goto bad;
431 if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)
432 goto bad;
433
434 src6 = src->sin6_addr;
435 if (sa6_recoverscope(src) != 0) {
436 /* XXX: should be impossible. */
437 goto bad;
438 }
439 sport = src->sin6_port;
440
441 dport = dst->sin6_port;
442 dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[12];
443 dst6 = &dst->sin6_addr;
444
445 if (IN6_IS_ADDR_MULTICAST(dst6) ||
446 (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {
447 /*
448 * Deliver a multicast or broadcast datagram to *all* sockets
449 * for which the local and remote addresses and ports match
450 * those of the incoming datagram. This allows more than
451 * one process to receive multi/broadcasts on the same port.
452 * (This really ought to be done for unicast datagrams as
453 * well, but that would cause problems with existing
454 * applications that open both address-specific sockets and
455 * a wildcard socket listening to the same port -- they would
456 * end up receiving duplicates of every unicast datagram.
457 * Those applications open the multiple sockets to overcome an
458 * inadequacy of the UDP socket interface, but for backwards
459 * compatibility we avoid the problem here rather than
460 * fixing the interface. Maybe 4.5BSD will remedy this?)
461 */
462
463 /*
464 * KAME note: traditionally we dropped udpiphdr from mbuf here.
465 * we need udpiphdr for IPsec processing so we do that later.
466 */
467 /*
468 * Locate pcb(s) for datagram.
469 */
470 TAILQ_FOREACH(inp, &udbtable.inpt_queue, inp_queue) {
471 if (inp->inp_af != AF_INET6)
472 continue;
473
474 if (inp->inp_lport != dport)
475 continue;
476 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_laddr(inp))) {
477 if (!IN6_ARE_ADDR_EQUAL(&in6p_laddr(inp),
478 dst6))
479 continue;
480 } else {
481 if (IN6_IS_ADDR_V4MAPPED(dst6) &&
482 (inp->inp_flags & IN6P_IPV6_V6ONLY))
483 continue;
484 }
485 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp))) {
486 if (!IN6_ARE_ADDR_EQUAL(&in6p_faddr(inp),
487 &src6) || inp->inp_fport != sport)
488 continue;
489 } else {
490 if (IN6_IS_ADDR_V4MAPPED(&src6) &&
491 (inp->inp_flags & IN6P_IPV6_V6ONLY))
492 continue;
493 }
494
495 udp6_sendup(m, off, sin6tosa(src), inp->inp_socket);
496 rcvcnt++;
497
498 /*
499 * Don't look for additional matches if this one does
500 * not have either the SO_REUSEPORT or SO_REUSEADDR
501 * socket options set. This heuristic avoids searching
502 * through all pcbs in the common case of a non-shared
503 * port. It assumes that an application will never
504 * clear these options after setting them.
505 */
506 if ((inp->inp_socket->so_options &
507 (SO_REUSEPORT|SO_REUSEADDR)) == 0)
508 break;
509 }
510 } else {
511 /*
512 * Locate pcb for datagram.
513 */
514 inp = in6pcb_lookup(&udbtable, &src6, sport, dst6,
515 dport, 0, 0);
516 if (inp == NULL) {
517 UDP_STATINC(UDP_STAT_PCBHASHMISS);
518 inp = in6pcb_lookup_bound(&udbtable, dst6, dport, 0);
519 if (inp == NULL)
520 return rcvcnt;
521 }
522
523 #ifdef IPSEC
524 /* Handle ESP over UDP */
525 if (inp->inp_flags & IN6P_ESPINUDP) {
526 switch (udp6_espinudp(mp, off)) {
527 case -1: /* Error, m was freed */
528 KASSERT(*mp == NULL);
529 rcvcnt = -1;
530 goto bad;
531
532 case 1: /* ESP over UDP */
533 KASSERT(*mp == NULL);
534 rcvcnt++;
535 goto bad;
536
537 case 0: /* plain UDP */
538 default: /* Unexpected */
539 /*
540 * Normal UDP processing will take place,
541 * m may have changed.
542 */
543 m = *mp;
544 break;
545 }
546 }
547 #endif
548
549 if (inp->inp_overudp_cb != NULL) {
550 int ret;
551 ret = inp->inp_overudp_cb(mp, off, inp->inp_socket,
552 sin6tosa(src), inp->inp_overudp_arg);
553 switch (ret) {
554 case -1: /* Error, m was freed */
555 KASSERT(*mp == NULL);
556 rcvcnt = -1;
557 goto bad;
558
559 case 1: /* Foo over UDP */
560 KASSERT(*mp == NULL);
561 rcvcnt++;
562 goto bad;
563
564 case 0: /* plain UDP */
565 default: /* Unexpected */
566 /*
567 * Normal UDP processing will take place,
568 * m may have changed.
569 */
570 m = *mp;
571 break;
572 }
573 }
574
575 udp6_sendup(m, off, sin6tosa(src), inp->inp_socket);
576 rcvcnt++;
577 }
578
579 bad:
580 return rcvcnt;
581 }
582
583 int
udp6_input_checksum(struct mbuf * m,const struct udphdr * uh,int off,int len)584 udp6_input_checksum(struct mbuf *m, const struct udphdr *uh, int off, int len)
585 {
586
587 /*
588 * XXX it's better to record and check if this mbuf is
589 * already checked.
590 */
591
592 if (__predict_false((m->m_flags & M_LOOP) && !udp_do_loopback_cksum)) {
593 goto good;
594 }
595 if (uh->uh_sum == 0) {
596 UDP6_STATINC(UDP6_STAT_NOSUM);
597 goto bad;
598 }
599
600 switch (m->m_pkthdr.csum_flags &
601 ((m_get_rcvif_NOMPSAFE(m)->if_csum_flags_rx & M_CSUM_UDPv6) |
602 M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
603 case M_CSUM_UDPv6|M_CSUM_TCP_UDP_BAD:
604 UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_bad);
605 UDP6_STATINC(UDP6_STAT_BADSUM);
606 goto bad;
607
608 #if 0 /* notyet */
609 case M_CSUM_UDPv6|M_CSUM_DATA:
610 #endif
611
612 case M_CSUM_UDPv6:
613 /* Checksum was okay. */
614 UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_ok);
615 break;
616
617 default:
618 /*
619 * Need to compute it ourselves. Maybe skip checksum
620 * on loopback interfaces.
621 */
622 UDP_CSUM_COUNTER_INCR(&udp6_swcsum);
623 if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {
624 UDP6_STATINC(UDP6_STAT_BADSUM);
625 goto bad;
626 }
627 }
628
629 good:
630 return 0;
631 bad:
632 return -1;
633 }
634
635 int
udp6_input(struct mbuf ** mp,int * offp,int proto)636 udp6_input(struct mbuf **mp, int *offp, int proto)
637 {
638 struct mbuf *m = *mp;
639 int off = *offp;
640 struct sockaddr_in6 src, dst;
641 struct ip6_hdr *ip6;
642 struct udphdr *uh;
643 u_int32_t plen, ulen;
644
645 ip6 = mtod(m, struct ip6_hdr *);
646
647 #if defined(NFAITH) && 0 < NFAITH
648 if (faithprefix(&ip6->ip6_dst)) {
649 /* send icmp6 host unreach? */
650 m_freem(m);
651 return IPPROTO_DONE;
652 }
653 #endif
654
655 UDP6_STATINC(UDP6_STAT_IPACKETS);
656
657 /* Check for jumbogram is done in ip6_input. We can trust pkthdr.len. */
658 plen = m->m_pkthdr.len - off;
659 IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));
660 if (uh == NULL) {
661 IP6_STATINC(IP6_STAT_TOOSHORT);
662 return IPPROTO_DONE;
663 }
664
665 /*
666 * Enforce alignment requirements that are violated in
667 * some cases, see kern/50766 for details.
668 */
669 if (ACCESSIBLE_POINTER(uh, struct udphdr) == 0) {
670 m = m_copyup(m, off + sizeof(struct udphdr), 0);
671 if (m == NULL) {
672 IP6_STATINC(IP6_STAT_TOOSHORT);
673 return IPPROTO_DONE;
674 }
675 ip6 = mtod(m, struct ip6_hdr *);
676 uh = (struct udphdr *)(mtod(m, char *) + off);
677 }
678 KASSERT(ACCESSIBLE_POINTER(uh, struct udphdr));
679 ulen = ntohs((u_short)uh->uh_ulen);
680
681 /*
682 * RFC2675 section 4: jumbograms will have 0 in the UDP header field,
683 * iff payload length > 0xffff.
684 */
685 if (ulen == 0 && plen > 0xffff)
686 ulen = plen;
687
688 if (plen != ulen) {
689 UDP6_STATINC(UDP6_STAT_BADLEN);
690 goto bad;
691 }
692
693 /* destination port of 0 is illegal, based on RFC768. */
694 if (uh->uh_dport == 0)
695 goto bad;
696
697 /*
698 * Checksum extended UDP header and data. Maybe skip checksum
699 * on loopback interfaces.
700 */
701 if (udp6_input_checksum(m, uh, off, ulen))
702 goto bad;
703
704 /*
705 * Construct source and dst sockaddrs.
706 */
707 memset(&src, 0, sizeof(src));
708 src.sin6_family = AF_INET6;
709 src.sin6_len = sizeof(struct sockaddr_in6);
710 src.sin6_addr = ip6->ip6_src;
711 src.sin6_port = uh->uh_sport;
712 memset(&dst, 0, sizeof(dst));
713 dst.sin6_family = AF_INET6;
714 dst.sin6_len = sizeof(struct sockaddr_in6);
715 dst.sin6_addr = ip6->ip6_dst;
716 dst.sin6_port = uh->uh_dport;
717
718 if (udp6_realinput(AF_INET6, &src, &dst, &m, off) == 0) {
719 if (m->m_flags & M_MCAST) {
720 UDP6_STATINC(UDP6_STAT_NOPORTMCAST);
721 goto bad;
722 }
723 UDP6_STATINC(UDP6_STAT_NOPORT);
724 icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
725 m = NULL;
726 }
727
728 bad:
729 m_freem(m);
730 return IPPROTO_DONE;
731 }
732
733 int
udp6_output(struct inpcb * const inp,struct mbuf * m,struct sockaddr_in6 * const addr6,struct mbuf * const control,struct lwp * const l)734 udp6_output(struct inpcb * const inp, struct mbuf *m,
735 struct sockaddr_in6 * const addr6, struct mbuf * const control,
736 struct lwp * const l)
737 {
738 u_int32_t ulen = m->m_pkthdr.len;
739 u_int32_t plen = sizeof(struct udphdr) + ulen;
740 struct ip6_hdr *ip6;
741 struct udphdr *udp6;
742 struct in6_addr _laddr, *laddr, *faddr;
743 struct in6_addr laddr_mapped; /* XXX ugly */
744 struct sockaddr_in6 *sin6 = NULL;
745 struct ifnet *oifp = NULL;
746 int scope_ambiguous = 0;
747 u_int16_t fport;
748 int error = 0;
749 struct ip6_pktopts *optp = NULL;
750 struct ip6_pktopts opt;
751 int af = AF_INET6, hlen = sizeof(struct ip6_hdr);
752 #ifdef INET
753 struct ip *ip;
754 struct udpiphdr *ui;
755 int flags = 0;
756 #endif
757 struct sockaddr_in6 tmp;
758
759 if (addr6) {
760 sin6 = addr6;
761 if (sin6->sin6_len != sizeof(*sin6)) {
762 error = EINVAL;
763 goto release;
764 }
765 if (sin6->sin6_family != AF_INET6) {
766 error = EAFNOSUPPORT;
767 goto release;
768 }
769
770 /* protect *sin6 from overwrites */
771 tmp = *sin6;
772 sin6 = &tmp;
773
774 /*
775 * Application should provide a proper zone ID or the use of
776 * default zone IDs should be enabled. Unfortunately, some
777 * applications do not behave as it should, so we need a
778 * workaround. Even if an appropriate ID is not determined,
779 * we'll see if we can determine the outgoing interface. If we
780 * can, determine the zone ID based on the interface below.
781 */
782 if (sin6->sin6_scope_id == 0 && !ip6_use_defzone)
783 scope_ambiguous = 1;
784 if ((error = sa6_embedscope(sin6, ip6_use_defzone)) != 0)
785 goto release;
786 }
787
788 if (control) {
789 if (__predict_false(l == NULL)) {
790 panic("%s: control but no lwp", __func__);
791 }
792 if ((error = ip6_setpktopts(control, &opt,
793 in6p_outputopts(inp), l->l_cred, IPPROTO_UDP)) != 0)
794 goto release;
795 optp = &opt;
796 } else
797 optp = in6p_outputopts(inp);
798
799
800 if (sin6) {
801 /*
802 * Slightly different than v4 version in that we call
803 * in6_selectsrc and in6pcb_set_port to fill in the local
804 * address and port rather than inpcb_connect. inpcb_connect
805 * sets inp_faddr which causes EISCONN below to be hit on
806 * subsequent sendto.
807 */
808 if (sin6->sin6_port == 0) {
809 error = EADDRNOTAVAIL;
810 goto release;
811 }
812
813 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp))) {
814 /* how about ::ffff:0.0.0.0 case? */
815 error = EISCONN;
816 goto release;
817 }
818
819 faddr = &sin6->sin6_addr;
820 fport = sin6->sin6_port; /* allow 0 port */
821
822 if (IN6_IS_ADDR_V4MAPPED(faddr)) {
823 if ((inp->inp_flags & IN6P_IPV6_V6ONLY)) {
824 /*
825 * I believe we should explicitly discard the
826 * packet when mapped addresses are disabled,
827 * rather than send the packet as an IPv6 one.
828 * If we chose the latter approach, the packet
829 * might be sent out on the wire based on the
830 * default route, the situation which we'd
831 * probably want to avoid.
832 * (20010421 jinmei@kame.net)
833 */
834 error = EINVAL;
835 goto release;
836 }
837 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_laddr(inp)) &&
838 !IN6_IS_ADDR_V4MAPPED(&in6p_laddr(inp))) {
839 /*
840 * when remote addr is an IPv4-mapped address,
841 * local addr should not be an IPv6 address,
842 * since you cannot determine how to map IPv6
843 * source address to IPv4.
844 */
845 error = EINVAL;
846 goto release;
847 }
848
849 af = AF_INET;
850 }
851
852 if (!IN6_IS_ADDR_V4MAPPED(faddr)) {
853 struct psref psref;
854 int bound = curlwp_bind();
855
856 error = in6_selectsrc(sin6, optp,
857 in6p_moptions(inp),
858 &inp->inp_route,
859 &in6p_laddr(inp), &oifp, &psref, &_laddr);
860 if (error)
861 laddr = NULL;
862 else
863 laddr = &_laddr;
864 if (oifp && scope_ambiguous &&
865 (error = in6_setscope(&sin6->sin6_addr,
866 oifp, NULL))) {
867 if_put(oifp, &psref);
868 curlwp_bindx(bound);
869 goto release;
870 }
871 if_put(oifp, &psref);
872 curlwp_bindx(bound);
873 } else {
874 /*
875 * XXX: freebsd[34] does not have in_selectsrc, but
876 * we can omit the whole part because freebsd4 calls
877 * udp_output() directly in this case, and thus we'll
878 * never see this path.
879 */
880 if (IN6_IS_ADDR_UNSPECIFIED(&in6p_laddr(inp))) {
881 struct sockaddr_in sin_dst;
882 struct in_addr ina;
883 struct in_ifaddr *ia4;
884 struct psref _psref;
885 int bound;
886
887 memcpy(&ina, &faddr->s6_addr[12], sizeof(ina));
888 sockaddr_in_init(&sin_dst, &ina, 0);
889 bound = curlwp_bind();
890 ia4 = in_selectsrc(&sin_dst, &inp->inp_route,
891 inp->inp_socket->so_options, NULL,
892 &error, &_psref);
893 if (ia4 == NULL) {
894 curlwp_bindx(bound);
895 if (error == 0)
896 error = EADDRNOTAVAIL;
897 goto release;
898 }
899 memset(&laddr_mapped, 0, sizeof(laddr_mapped));
900 laddr_mapped.s6_addr16[5] = 0xffff; /* ugly */
901 memcpy(&laddr_mapped.s6_addr[12],
902 &IA_SIN(ia4)->sin_addr,
903 sizeof(IA_SIN(ia4)->sin_addr));
904 ia4_release(ia4, &_psref);
905 curlwp_bindx(bound);
906 laddr = &laddr_mapped;
907 } else
908 {
909 laddr = &in6p_laddr(inp); /* XXX */
910 }
911 }
912 if (laddr == NULL) {
913 if (error == 0)
914 error = EADDRNOTAVAIL;
915 goto release;
916 }
917 if (inp->inp_lport == 0) {
918 /*
919 * Craft a sockaddr_in6 for the local endpoint. Use the
920 * "any" as a base, set the address, and recover the
921 * scope.
922 */
923 struct sockaddr_in6 lsin6 =
924 *((const struct sockaddr_in6 *)inp->inp_socket->so_proto->pr_domain->dom_sa_any);
925 lsin6.sin6_addr = *laddr;
926 error = sa6_recoverscope(&lsin6);
927 if (error)
928 goto release;
929
930 error = in6pcb_set_port(&lsin6, inp, l);
931
932 if (error) {
933 in6p_laddr(inp) = in6addr_any;
934 goto release;
935 }
936 }
937 } else {
938 if (IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp))) {
939 error = ENOTCONN;
940 goto release;
941 }
942 if (IN6_IS_ADDR_V4MAPPED(&in6p_faddr(inp))) {
943 if ((inp->inp_flags & IN6P_IPV6_V6ONLY))
944 {
945 /*
946 * XXX: this case would happen when the
947 * application sets the V6ONLY flag after
948 * connecting the foreign address.
949 * Such applications should be fixed,
950 * so we bark here.
951 */
952 log(LOG_INFO, "udp6_output: IPV6_V6ONLY "
953 "option was set for a connected socket\n");
954 error = EINVAL;
955 goto release;
956 } else
957 af = AF_INET;
958 }
959 laddr = &in6p_laddr(inp);
960 faddr = &in6p_faddr(inp);
961 fport = inp->inp_fport;
962 }
963
964 if (af == AF_INET)
965 hlen = sizeof(struct ip);
966
967 /*
968 * Calculate data length and get a mbuf
969 * for UDP and IP6 headers.
970 */
971 M_PREPEND(m, hlen + sizeof(struct udphdr), M_DONTWAIT);
972 if (m == NULL) {
973 error = ENOBUFS;
974 goto release;
975 }
976
977 /*
978 * Stuff checksum and output datagram.
979 */
980 udp6 = (struct udphdr *)(mtod(m, char *) + hlen);
981 udp6->uh_sport = inp->inp_lport; /* lport is always set in the PCB */
982 udp6->uh_dport = fport;
983 if (plen <= 0xffff)
984 udp6->uh_ulen = htons((u_int16_t)plen);
985 else
986 udp6->uh_ulen = 0;
987 udp6->uh_sum = 0;
988
989 switch (af) {
990 case AF_INET6:
991 ip6 = mtod(m, struct ip6_hdr *);
992 ip6->ip6_flow = in6p_flowinfo(inp) & IPV6_FLOWINFO_MASK;
993 ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
994 ip6->ip6_vfc |= IPV6_VERSION;
995 #if 0 /* ip6_plen will be filled in ip6_output. */
996 ip6->ip6_plen = htons((u_int16_t)plen);
997 #endif
998 ip6->ip6_nxt = IPPROTO_UDP;
999 ip6->ip6_hlim = in6pcb_selecthlim_rt(inp);
1000 ip6->ip6_src = *laddr;
1001 ip6->ip6_dst = *faddr;
1002
1003 udp6->uh_sum = in6_cksum_phdr(laddr, faddr,
1004 htonl(plen), htonl(IPPROTO_UDP));
1005 m->m_pkthdr.csum_flags = M_CSUM_UDPv6;
1006 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
1007
1008 UDP6_STATINC(UDP6_STAT_OPACKETS);
1009 error = ip6_output(m, optp, &inp->inp_route, 0,
1010 in6p_moptions(inp), inp, NULL);
1011 break;
1012 case AF_INET:
1013 #ifdef INET
1014 /* can't transmit jumbogram over IPv4 */
1015 if (plen > 0xffff) {
1016 error = EMSGSIZE;
1017 goto release;
1018 }
1019
1020 ip = mtod(m, struct ip *);
1021 ui = (struct udpiphdr *)ip;
1022 memset(ui->ui_x1, 0, sizeof(ui->ui_x1));
1023 ui->ui_pr = IPPROTO_UDP;
1024 ui->ui_len = htons(plen);
1025 memcpy(&ui->ui_src, &laddr->s6_addr[12], sizeof(ui->ui_src));
1026 ui->ui_ulen = ui->ui_len;
1027
1028 flags = (inp->inp_socket->so_options &
1029 (SO_DONTROUTE | SO_BROADCAST));
1030 memcpy(&ui->ui_dst, &faddr->s6_addr[12], sizeof(ui->ui_dst));
1031
1032 udp6->uh_sum = in_cksum(m, hlen + plen);
1033 if (udp6->uh_sum == 0)
1034 udp6->uh_sum = 0xffff;
1035
1036 ip->ip_len = htons(hlen + plen);
1037 ip->ip_ttl = in6pcb_selecthlim(inp, NULL); /* XXX */
1038 ip->ip_tos = 0; /* XXX */
1039
1040 UDP_STATINC(UDP_STAT_OPACKETS);
1041 error = ip_output(m, NULL, &inp->inp_route, flags /* XXX */,
1042 inp->inp_moptions, NULL);
1043 break;
1044 #else
1045 error = EAFNOSUPPORT;
1046 goto release;
1047 #endif
1048 }
1049 goto releaseopt;
1050
1051 release:
1052 m_freem(m);
1053
1054 releaseopt:
1055 if (control) {
1056 if (optp == &opt)
1057 ip6_clearpktopts(&opt, -1);
1058 m_freem(control);
1059 }
1060 return (error);
1061 }
1062
1063 static int
udp6_attach(struct socket * so,int proto)1064 udp6_attach(struct socket *so, int proto)
1065 {
1066 struct inpcb *inp;
1067 int s, error;
1068
1069 KASSERT(sotoinpcb(so) == NULL);
1070 sosetlock(so);
1071
1072 error = soreserve(so, udp6_sendspace, udp6_recvspace);
1073 if (error) {
1074 return error;
1075 }
1076
1077 /*
1078 * MAPPED_ADDR implementation spec:
1079 * Always attach for IPv6, and only when necessary for IPv4.
1080 */
1081 s = splsoftnet();
1082 error = inpcb_create(so, &udbtable);
1083 splx(s);
1084 if (error) {
1085 return error;
1086 }
1087
1088 inp = sotoinpcb(so);
1089 in6p_cksum(inp) = -1; /* just to be sure */
1090
1091 KASSERT(solocked(so));
1092 return 0;
1093 }
1094
1095 static void
udp6_detach(struct socket * so)1096 udp6_detach(struct socket *so)
1097 {
1098 struct inpcb *inp = sotoinpcb(so);
1099 int s;
1100
1101 KASSERT(solocked(so));
1102 KASSERT(inp != NULL);
1103
1104 s = splsoftnet();
1105 inpcb_destroy(inp);
1106 splx(s);
1107 }
1108
1109 static int
udp6_accept(struct socket * so,struct sockaddr * nam)1110 udp6_accept(struct socket *so, struct sockaddr *nam)
1111 {
1112 KASSERT(solocked(so));
1113
1114 return EOPNOTSUPP;
1115 }
1116
1117 static int
udp6_bind(struct socket * so,struct sockaddr * nam,struct lwp * l)1118 udp6_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
1119 {
1120 struct inpcb *inp = sotoinpcb(so);
1121 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
1122 int error = 0;
1123 int s;
1124
1125 KASSERT(solocked(so));
1126 KASSERT(inp != NULL);
1127
1128 s = splsoftnet();
1129 error = in6pcb_bind(inp, sin6, l);
1130 splx(s);
1131 return error;
1132 }
1133
1134 static int
udp6_listen(struct socket * so,struct lwp * l)1135 udp6_listen(struct socket *so, struct lwp *l)
1136 {
1137 KASSERT(solocked(so));
1138
1139 return EOPNOTSUPP;
1140 }
1141
1142 static int
udp6_connect(struct socket * so,struct sockaddr * nam,struct lwp * l)1143 udp6_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
1144 {
1145 struct inpcb *inp = sotoinpcb(so);
1146 int error = 0;
1147 int s;
1148
1149 KASSERT(solocked(so));
1150 KASSERT(inp != NULL);
1151
1152 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp)))
1153 return EISCONN;
1154 s = splsoftnet();
1155 error = in6pcb_connect(inp, (struct sockaddr_in6 *)nam, l);
1156 splx(s);
1157 if (error == 0)
1158 soisconnected(so);
1159
1160 return error;
1161 }
1162
1163 static int
udp6_connect2(struct socket * so,struct socket * so2)1164 udp6_connect2(struct socket *so, struct socket *so2)
1165 {
1166 KASSERT(solocked(so));
1167
1168 return EOPNOTSUPP;
1169 }
1170
1171 static int
udp6_disconnect(struct socket * so)1172 udp6_disconnect(struct socket *so)
1173 {
1174 struct inpcb *inp = sotoinpcb(so);
1175 int s;
1176
1177 KASSERT(solocked(so));
1178 KASSERT(inp != NULL);
1179
1180 if (IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp)))
1181 return ENOTCONN;
1182
1183 s = splsoftnet();
1184 in6pcb_disconnect(inp);
1185 memset((void *)&in6p_laddr(inp), 0, sizeof(in6p_laddr(inp)));
1186 splx(s);
1187
1188 so->so_state &= ~SS_ISCONNECTED; /* XXX */
1189 in6pcb_set_state(inp, INP_BOUND); /* XXX */
1190 return 0;
1191 }
1192
1193 static int
udp6_shutdown(struct socket * so)1194 udp6_shutdown(struct socket *so)
1195 {
1196 int s;
1197
1198 s = splsoftnet();
1199 socantsendmore(so);
1200 splx(s);
1201
1202 return 0;
1203 }
1204
1205 static int
udp6_abort(struct socket * so)1206 udp6_abort(struct socket *so)
1207 {
1208 int s;
1209
1210 KASSERT(solocked(so));
1211 KASSERT(sotoinpcb(so) != NULL);
1212
1213 s = splsoftnet();
1214 soisdisconnected(so);
1215 inpcb_destroy(sotoinpcb(so));
1216 splx(s);
1217
1218 return 0;
1219 }
1220
1221 static int
udp6_ioctl(struct socket * so,u_long cmd,void * addr6,struct ifnet * ifp)1222 udp6_ioctl(struct socket *so, u_long cmd, void *addr6, struct ifnet *ifp)
1223 {
1224 /*
1225 * MAPPED_ADDR implementation info:
1226 * Mapped addr support for PRU_CONTROL is not necessary.
1227 * Because typical user of PRU_CONTROL is such as ifconfig,
1228 * and they don't associate any addr to their socket. Then
1229 * socket family is only hint about the PRU_CONTROL'ed address
1230 * family, especially when getting addrs from kernel.
1231 * So AF_INET socket need to be used to control AF_INET addrs,
1232 * and AF_INET6 socket for AF_INET6 addrs.
1233 */
1234 return in6_control(so, cmd, addr6, ifp);
1235 }
1236
1237 static int
udp6_stat(struct socket * so,struct stat * ub)1238 udp6_stat(struct socket *so, struct stat *ub)
1239 {
1240 KASSERT(solocked(so));
1241
1242 /* stat: don't bother with a blocksize */
1243 return 0;
1244 }
1245
1246 static int
udp6_peeraddr(struct socket * so,struct sockaddr * nam)1247 udp6_peeraddr(struct socket *so, struct sockaddr *nam)
1248 {
1249 KASSERT(solocked(so));
1250 KASSERT(sotoinpcb(so) != NULL);
1251 KASSERT(nam != NULL);
1252
1253 in6pcb_fetch_peeraddr(sotoinpcb(so), (struct sockaddr_in6 *)nam);
1254 return 0;
1255 }
1256
1257 static int
udp6_sockaddr(struct socket * so,struct sockaddr * nam)1258 udp6_sockaddr(struct socket *so, struct sockaddr *nam)
1259 {
1260 KASSERT(solocked(so));
1261 KASSERT(sotoinpcb(so) != NULL);
1262 KASSERT(nam != NULL);
1263
1264 in6pcb_fetch_sockaddr(sotoinpcb(so), (struct sockaddr_in6 *)nam);
1265 return 0;
1266 }
1267
1268 static int
udp6_rcvd(struct socket * so,int flags,struct lwp * l)1269 udp6_rcvd(struct socket *so, int flags, struct lwp *l)
1270 {
1271 KASSERT(solocked(so));
1272
1273 return EOPNOTSUPP;
1274 }
1275
1276 static int
udp6_recvoob(struct socket * so,struct mbuf * m,int flags)1277 udp6_recvoob(struct socket *so, struct mbuf *m, int flags)
1278 {
1279 KASSERT(solocked(so));
1280
1281 return EOPNOTSUPP;
1282 }
1283
1284 static int
udp6_send(struct socket * so,struct mbuf * m,struct sockaddr * nam,struct mbuf * control,struct lwp * l)1285 udp6_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
1286 struct mbuf *control, struct lwp *l)
1287 {
1288 struct inpcb *inp = sotoinpcb(so);
1289 int error = 0;
1290 int s;
1291
1292 KASSERT(solocked(so));
1293 KASSERT(inp != NULL);
1294 KASSERT(m != NULL);
1295
1296 s = splsoftnet();
1297 error = udp6_output(inp, m, (struct sockaddr_in6 *)nam, control, l);
1298 splx(s);
1299
1300 return error;
1301 }
1302
1303 static int
udp6_sendoob(struct socket * so,struct mbuf * m,struct mbuf * control)1304 udp6_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
1305 {
1306 KASSERT(solocked(so));
1307
1308 m_freem(m);
1309 m_freem(control);
1310
1311 return EOPNOTSUPP;
1312 }
1313
1314 static int
udp6_purgeif(struct socket * so,struct ifnet * ifp)1315 udp6_purgeif(struct socket *so, struct ifnet *ifp)
1316 {
1317
1318 mutex_enter(softnet_lock);
1319 in6pcb_purgeif0(&udbtable, ifp);
1320 #ifdef NET_MPSAFE
1321 mutex_exit(softnet_lock);
1322 #endif
1323 in6_purgeif(ifp);
1324 #ifdef NET_MPSAFE
1325 mutex_enter(softnet_lock);
1326 #endif
1327 in6pcb_purgeif(&udbtable, ifp);
1328 mutex_exit(softnet_lock);
1329
1330 return 0;
1331 }
1332
1333 static int
sysctl_net_inet6_udp6_stats(SYSCTLFN_ARGS)1334 sysctl_net_inet6_udp6_stats(SYSCTLFN_ARGS)
1335 {
1336
1337 return (NETSTAT_SYSCTL(udp6stat_percpu, UDP6_NSTATS));
1338 }
1339
1340 static void
sysctl_net_inet6_udp6_setup(struct sysctllog ** clog)1341 sysctl_net_inet6_udp6_setup(struct sysctllog **clog)
1342 {
1343
1344 sysctl_createv(clog, 0, NULL, NULL,
1345 CTLFLAG_PERMANENT,
1346 CTLTYPE_NODE, "inet6", NULL,
1347 NULL, 0, NULL, 0,
1348 CTL_NET, PF_INET6, CTL_EOL);
1349 sysctl_createv(clog, 0, NULL, NULL,
1350 CTLFLAG_PERMANENT,
1351 CTLTYPE_NODE, "udp6",
1352 SYSCTL_DESCR("UDPv6 related settings"),
1353 NULL, 0, NULL, 0,
1354 CTL_NET, PF_INET6, IPPROTO_UDP, CTL_EOL);
1355
1356 sysctl_createv(clog, 0, NULL, NULL,
1357 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1358 CTLTYPE_INT, "sendspace",
1359 SYSCTL_DESCR("Default UDP send buffer size"),
1360 NULL, 0, &udp6_sendspace, 0,
1361 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_SENDSPACE,
1362 CTL_EOL);
1363 sysctl_createv(clog, 0, NULL, NULL,
1364 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1365 CTLTYPE_INT, "recvspace",
1366 SYSCTL_DESCR("Default UDP receive buffer size"),
1367 NULL, 0, &udp6_recvspace, 0,
1368 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_RECVSPACE,
1369 CTL_EOL);
1370 sysctl_createv(clog, 0, NULL, NULL,
1371 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1372 CTLTYPE_INT, "do_loopback_cksum",
1373 SYSCTL_DESCR("Perform UDP checksum on loopback"),
1374 NULL, 0, &udp_do_loopback_cksum, 0,
1375 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_LOOPBACKCKSUM,
1376 CTL_EOL);
1377 sysctl_createv(clog, 0, NULL, NULL,
1378 CTLFLAG_PERMANENT,
1379 CTLTYPE_STRUCT, "pcblist",
1380 SYSCTL_DESCR("UDP protocol control block list"),
1381 sysctl_inpcblist, 0, &udbtable, 0,
1382 CTL_NET, PF_INET6, IPPROTO_UDP, CTL_CREATE,
1383 CTL_EOL);
1384 sysctl_createv(clog, 0, NULL, NULL,
1385 CTLFLAG_PERMANENT,
1386 CTLTYPE_STRUCT, "stats",
1387 SYSCTL_DESCR("UDPv6 statistics"),
1388 sysctl_net_inet6_udp6_stats, 0, NULL, 0,
1389 CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_STATS,
1390 CTL_EOL);
1391 }
1392
1393 void
udp6_statinc(u_int stat)1394 udp6_statinc(u_int stat)
1395 {
1396
1397 KASSERT(stat < UDP6_NSTATS);
1398 UDP6_STATINC(stat);
1399 }
1400
1401 #ifdef IPSEC
1402 /*
1403 * Returns:
1404 * 1 if the packet was processed
1405 * 0 if normal UDP processing should take place
1406 * -1 if an error occurred and m was freed
1407 */
1408 static int
udp6_espinudp(struct mbuf ** mp,int off)1409 udp6_espinudp(struct mbuf **mp, int off)
1410 {
1411 const size_t skip = sizeof(struct udphdr);
1412 size_t len;
1413 void *data;
1414 size_t minlen;
1415 int ip6hdrlen;
1416 struct ip6_hdr *ip6;
1417 struct m_tag *tag;
1418 struct udphdr *udphdr;
1419 u_int16_t sport, dport;
1420 struct mbuf *m = *mp;
1421 uint32_t *marker;
1422
1423 /*
1424 * Collapse the mbuf chain if the first mbuf is too short
1425 * The longest case is: UDP + non ESP marker + ESP
1426 */
1427 minlen = off + sizeof(u_int64_t) + sizeof(struct esp);
1428 if (minlen > m->m_pkthdr.len)
1429 minlen = m->m_pkthdr.len;
1430
1431 if (m->m_len < minlen) {
1432 if ((*mp = m_pullup(m, minlen)) == NULL) {
1433 return -1; /* dropped */
1434 }
1435 m = *mp;
1436 }
1437
1438 len = m->m_len - off;
1439 data = mtod(m, char *) + off;
1440
1441 /* Ignore keepalive packets */
1442 if ((len == 1) && (*(unsigned char *)data == 0xff)) {
1443 m_freem(m);
1444 *mp = NULL; /* avoid any further processing by caller ... */
1445 return 1; /* consumed */
1446 }
1447
1448 /* Handle Non-ESP marker (32bit). If zero, then IKE. */
1449 marker = (uint32_t *)data;
1450 if (len <= sizeof(uint32_t))
1451 return 0; /* passthrough */
1452 if (marker[0] == 0)
1453 return 0; /* passthrough */
1454
1455 /*
1456 * Get the UDP ports. They are handled in network
1457 * order everywhere in IPSEC_NAT_T code.
1458 */
1459 udphdr = (struct udphdr *)((char *)data - skip);
1460 sport = udphdr->uh_sport;
1461 dport = udphdr->uh_dport;
1462
1463 /*
1464 * Remove the UDP header (and possibly the non ESP marker)
1465 * IPv6 header length is ip6hdrlen
1466 * Before:
1467 * <---- off --->
1468 * +-----+------+-----+
1469 * | IP6 | UDP | ESP |
1470 * +-----+------+-----+
1471 * <-skip->
1472 * After:
1473 * +-----+-----+
1474 * | IP6 | ESP |
1475 * +-----+-----+
1476 * <-skip->
1477 */
1478 ip6hdrlen = off - sizeof(struct udphdr);
1479 memmove(mtod(m, char *) + skip, mtod(m, void *), ip6hdrlen);
1480 m_adj(m, skip);
1481
1482 ip6 = mtod(m, struct ip6_hdr *);
1483 ip6->ip6_plen = htons(ntohs(ip6->ip6_plen) - skip);
1484 ip6->ip6_nxt = IPPROTO_ESP;
1485
1486 /*
1487 * We have modified the packet - it is now ESP, so we should not
1488 * return to UDP processing ...
1489 *
1490 * Add a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember
1491 * the source UDP port. This is required if we want
1492 * to select the right SPD for multiple hosts behind
1493 * same NAT
1494 */
1495 if ((tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,
1496 sizeof(sport) + sizeof(dport), M_DONTWAIT)) == NULL) {
1497 m_freem(m);
1498 *mp = NULL;
1499 return -1; /* dropped */
1500 }
1501 ((u_int16_t *)(tag + 1))[0] = sport;
1502 ((u_int16_t *)(tag + 1))[1] = dport;
1503 m_tag_prepend(m, tag);
1504
1505 if (ipsec_used)
1506 ipsec6_common_input(&m, &ip6hdrlen, IPPROTO_ESP);
1507 else
1508 m_freem(m);
1509
1510 /* We handled it, it shouldn't be handled by UDP */
1511 *mp = NULL; /* avoid free by caller ... */
1512 return 1; /* consumed */
1513 }
1514 #endif /* IPSEC */
1515
1516 PR_WRAP_USRREQS(udp6)
1517 #define udp6_attach udp6_attach_wrapper
1518 #define udp6_detach udp6_detach_wrapper
1519 #define udp6_accept udp6_accept_wrapper
1520 #define udp6_bind udp6_bind_wrapper
1521 #define udp6_listen udp6_listen_wrapper
1522 #define udp6_connect udp6_connect_wrapper
1523 #define udp6_connect2 udp6_connect2_wrapper
1524 #define udp6_disconnect udp6_disconnect_wrapper
1525 #define udp6_shutdown udp6_shutdown_wrapper
1526 #define udp6_abort udp6_abort_wrapper
1527 #define udp6_ioctl udp6_ioctl_wrapper
1528 #define udp6_stat udp6_stat_wrapper
1529 #define udp6_peeraddr udp6_peeraddr_wrapper
1530 #define udp6_sockaddr udp6_sockaddr_wrapper
1531 #define udp6_rcvd udp6_rcvd_wrapper
1532 #define udp6_recvoob udp6_recvoob_wrapper
1533 #define udp6_send udp6_send_wrapper
1534 #define udp6_sendoob udp6_sendoob_wrapper
1535 #define udp6_purgeif udp6_purgeif_wrapper
1536
1537 const struct pr_usrreqs udp6_usrreqs = {
1538 .pr_attach = udp6_attach,
1539 .pr_detach = udp6_detach,
1540 .pr_accept = udp6_accept,
1541 .pr_bind = udp6_bind,
1542 .pr_listen = udp6_listen,
1543 .pr_connect = udp6_connect,
1544 .pr_connect2 = udp6_connect2,
1545 .pr_disconnect = udp6_disconnect,
1546 .pr_shutdown = udp6_shutdown,
1547 .pr_abort = udp6_abort,
1548 .pr_ioctl = udp6_ioctl,
1549 .pr_stat = udp6_stat,
1550 .pr_peeraddr = udp6_peeraddr,
1551 .pr_sockaddr = udp6_sockaddr,
1552 .pr_rcvd = udp6_rcvd,
1553 .pr_recvoob = udp6_recvoob,
1554 .pr_send = udp6_send,
1555 .pr_sendoob = udp6_sendoob,
1556 .pr_purgeif = udp6_purgeif,
1557 };
1558