1 /* $NetBSD: udp_usrreq.c,v 1.173 2008/08/06 15:01:23 plunky Exp $ */
2
3 /*
4 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
34 * The Regents of the University of California. All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)udp_usrreq.c 8.6 (Berkeley) 5/23/95
61 */
62
63 #include <sys/cdefs.h>
64 __KERNEL_RCSID(0, "$NetBSD: udp_usrreq.c,v 1.173 2008/08/06 15:01:23 plunky Exp $");
65
66 #include "opt_inet.h"
67 #include "opt_ipsec.h"
68 #include "opt_inet_csum.h"
69 #include "opt_ipkdb.h"
70 #include "opt_mbuftrace.h"
71
72 #include <sys/param.h>
73 #include <sys/malloc.h>
74 #include <sys/mbuf.h>
75 #include <sys/protosw.h>
76 #include <sys/socket.h>
77 #include <sys/socketvar.h>
78 #include <sys/errno.h>
79 #include <sys/stat.h>
80 #include <sys/systm.h>
81 #include <sys/proc.h>
82 #include <sys/domain.h>
83 #include <sys/sysctl.h>
84
85 #include <net/if.h>
86 #include <net/route.h>
87
88 #include <netinet/in.h>
89 #include <netinet/in_systm.h>
90 #include <netinet/in_var.h>
91 #include <netinet/ip.h>
92 #include <netinet/in_pcb.h>
93 #include <netinet/ip_var.h>
94 #include <netinet/ip_icmp.h>
95 #include <netinet/udp.h>
96 #include <netinet/udp_var.h>
97 #include <netinet/udp_private.h>
98
99 #ifdef INET6
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/scope6_var.h>
108 #endif
109
110 #ifndef INET6
111 /* always need ip6.h for IP6_EXTHDR_GET */
112 #include <netinet/ip6.h>
113 #endif
114
115 #include "faith.h"
116 #if defined(NFAITH) && NFAITH > 0
117 #include <net/if_faith.h>
118 #endif
119
120 #include <machine/stdarg.h>
121
122 #ifdef FAST_IPSEC
123 #include <netipsec/ipsec.h>
124 #include <netipsec/ipsec_var.h>
125 #include <netipsec/ipsec_private.h>
126 #include <netipsec/esp.h>
127 #ifdef INET6
128 #include <netipsec/ipsec6.h>
129 #endif
130 #endif /* FAST_IPSEC */
131
132 #ifdef IPSEC
133 #include <netinet6/ipsec.h>
134 #include <netinet6/ipsec_private.h>
135 #include <netinet6/esp.h>
136 #include <netkey/key.h>
137 #endif /* IPSEC */
138
139 #ifdef IPKDB
140 #include <ipkdb/ipkdb.h>
141 #endif
142
143 /*
144 * UDP protocol implementation.
145 * Per RFC 768, August, 1980.
146 */
147 int udpcksum = 1;
148 int udp_do_loopback_cksum = 0;
149
150 struct inpcbtable udbtable;
151
152 percpu_t *udpstat_percpu;
153
154 #ifdef INET
155 #ifdef IPSEC_NAT_T
156 static int udp4_espinudp (struct mbuf **, int, struct sockaddr *,
157 struct socket *);
158 #endif
159 static void udp4_sendup (struct mbuf *, int, struct sockaddr *,
160 struct socket *);
161 static int udp4_realinput (struct sockaddr_in *, struct sockaddr_in *,
162 struct mbuf **, int);
163 static int udp4_input_checksum(struct mbuf *, const struct udphdr *, int, int);
164 #endif
165 #ifdef INET6
166 static void udp6_sendup (struct mbuf *, int, struct sockaddr *,
167 struct socket *);
168 static int udp6_realinput (int, struct sockaddr_in6 *,
169 struct sockaddr_in6 *, struct mbuf *, int);
170 static int udp6_input_checksum(struct mbuf *, const struct udphdr *, int, int);
171 #endif
172 #ifdef INET
173 static void udp_notify (struct inpcb *, int);
174 #endif
175
176 #ifndef UDBHASHSIZE
177 #define UDBHASHSIZE 128
178 #endif
179 int udbhashsize = UDBHASHSIZE;
180
181 #ifdef MBUFTRACE
182 struct mowner udp_mowner = MOWNER_INIT("udp", "");
183 struct mowner udp_rx_mowner = MOWNER_INIT("udp", "rx");
184 struct mowner udp_tx_mowner = MOWNER_INIT("udp", "tx");
185 #endif
186
187 #ifdef UDP_CSUM_COUNTERS
188 #include <sys/device.h>
189
190 #if defined(INET)
191 struct evcnt udp_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
192 NULL, "udp", "hwcsum bad");
193 struct evcnt udp_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
194 NULL, "udp", "hwcsum ok");
195 struct evcnt udp_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
196 NULL, "udp", "hwcsum data");
197 struct evcnt udp_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
198 NULL, "udp", "swcsum");
199
200 EVCNT_ATTACH_STATIC(udp_hwcsum_bad);
201 EVCNT_ATTACH_STATIC(udp_hwcsum_ok);
202 EVCNT_ATTACH_STATIC(udp_hwcsum_data);
203 EVCNT_ATTACH_STATIC(udp_swcsum);
204 #endif /* defined(INET) */
205
206 #if defined(INET6)
207 struct evcnt udp6_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
208 NULL, "udp6", "hwcsum bad");
209 struct evcnt udp6_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
210 NULL, "udp6", "hwcsum ok");
211 struct evcnt udp6_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
212 NULL, "udp6", "hwcsum data");
213 struct evcnt udp6_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
214 NULL, "udp6", "swcsum");
215
216 EVCNT_ATTACH_STATIC(udp6_hwcsum_bad);
217 EVCNT_ATTACH_STATIC(udp6_hwcsum_ok);
218 EVCNT_ATTACH_STATIC(udp6_hwcsum_data);
219 EVCNT_ATTACH_STATIC(udp6_swcsum);
220 #endif /* defined(INET6) */
221
222 #define UDP_CSUM_COUNTER_INCR(ev) (ev)->ev_count++
223
224 #else
225
226 #define UDP_CSUM_COUNTER_INCR(ev) /* nothing */
227
228 #endif /* UDP_CSUM_COUNTERS */
229
230 void
231 udp_init(void)
232 {
233
234 in_pcbinit(&udbtable, udbhashsize, udbhashsize);
235
236 MOWNER_ATTACH(&udp_tx_mowner);
237 MOWNER_ATTACH(&udp_rx_mowner);
238 MOWNER_ATTACH(&udp_mowner);
239
240 #ifdef INET
241 udpstat_percpu = percpu_alloc(sizeof(uint64_t) * UDP_NSTATS);
242 #endif
243 #ifdef INET6
244 udp6stat_percpu = percpu_alloc(sizeof(uint64_t) * UDP6_NSTATS);
245 #endif
246 }
247
248 /*
249 * Checksum extended UDP header and data.
250 */
251
252 int
253 udp_input_checksum(int af, struct mbuf *m, const struct udphdr *uh,
254 int iphlen, int len)
255 {
256
257 switch (af) {
258 #ifdef INET
259 case AF_INET:
260 return udp4_input_checksum(m, uh, iphlen, len);
261 #endif
262 #ifdef INET6
263 case AF_INET6:
264 return udp6_input_checksum(m, uh, iphlen, len);
265 #endif
266 }
267 #ifdef DIAGNOSTIC
268 panic("udp_input_checksum: unknown af %d", af);
269 #endif
270 /* NOTREACHED */
271 return -1;
272 }
273
274 #ifdef INET
275
276 /*
277 * Checksum extended UDP header and data.
278 */
279
280 static int
281 udp4_input_checksum(struct mbuf *m, const struct udphdr *uh,
282 int iphlen, int len)
283 {
284
285 /*
286 * XXX it's better to record and check if this mbuf is
287 * already checked.
288 */
289
290 if (uh->uh_sum == 0)
291 return 0;
292
293 switch (m->m_pkthdr.csum_flags &
294 ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv4) |
295 M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
296 case M_CSUM_UDPv4|M_CSUM_TCP_UDP_BAD:
297 UDP_CSUM_COUNTER_INCR(&udp_hwcsum_bad);
298 goto badcsum;
299
300 case M_CSUM_UDPv4|M_CSUM_DATA: {
301 u_int32_t hw_csum = m->m_pkthdr.csum_data;
302
303 UDP_CSUM_COUNTER_INCR(&udp_hwcsum_data);
304 if (m->m_pkthdr.csum_flags & M_CSUM_NO_PSEUDOHDR) {
305 const struct ip *ip =
306 mtod(m, const struct ip *);
307
308 hw_csum = in_cksum_phdr(ip->ip_src.s_addr,
309 ip->ip_dst.s_addr,
310 htons(hw_csum + len + IPPROTO_UDP));
311 }
312 if ((hw_csum ^ 0xffff) != 0)
313 goto badcsum;
314 break;
315 }
316
317 case M_CSUM_UDPv4:
318 /* Checksum was okay. */
319 UDP_CSUM_COUNTER_INCR(&udp_hwcsum_ok);
320 break;
321
322 default:
323 /*
324 * Need to compute it ourselves. Maybe skip checksum
325 * on loopback interfaces.
326 */
327 if (__predict_true(!(m->m_pkthdr.rcvif->if_flags &
328 IFF_LOOPBACK) ||
329 udp_do_loopback_cksum)) {
330 UDP_CSUM_COUNTER_INCR(&udp_swcsum);
331 if (in4_cksum(m, IPPROTO_UDP, iphlen, len) != 0)
332 goto badcsum;
333 }
334 break;
335 }
336
337 return 0;
338
339 badcsum:
340 UDP_STATINC(UDP_STAT_BADSUM);
341 return -1;
342 }
343
344 void
345 udp_input(struct mbuf *m, ...)
346 {
347 va_list ap;
348 struct sockaddr_in src, dst;
349 struct ip *ip;
350 struct udphdr *uh;
351 int iphlen;
352 int len;
353 int n;
354 u_int16_t ip_len;
355
356 va_start(ap, m);
357 iphlen = va_arg(ap, int);
358 (void)va_arg(ap, int); /* ignore value, advance ap */
359 va_end(ap);
360
361 MCLAIM(m, &udp_rx_mowner);
362 UDP_STATINC(UDP_STAT_IPACKETS);
363
364 /*
365 * Get IP and UDP header together in first mbuf.
366 */
367 ip = mtod(m, struct ip *);
368 IP6_EXTHDR_GET(uh, struct udphdr *, m, iphlen, sizeof(struct udphdr));
369 if (uh == NULL) {
370 UDP_STATINC(UDP_STAT_HDROPS);
371 return;
372 }
373 KASSERT(UDP_HDR_ALIGNED_P(uh));
374
375 /* destination port of 0 is illegal, based on RFC768. */
376 if (uh->uh_dport == 0)
377 goto bad;
378
379 /*
380 * Make mbuf data length reflect UDP length.
381 * If not enough data to reflect UDP length, drop.
382 */
383 ip_len = ntohs(ip->ip_len);
384 len = ntohs((u_int16_t)uh->uh_ulen);
385 if (ip_len != iphlen + len) {
386 if (ip_len < iphlen + len || len < sizeof(struct udphdr)) {
387 UDP_STATINC(UDP_STAT_BADLEN);
388 goto bad;
389 }
390 m_adj(m, iphlen + len - ip_len);
391 }
392
393 /*
394 * Checksum extended UDP header and data.
395 */
396 if (udp4_input_checksum(m, uh, iphlen, len))
397 goto badcsum;
398
399 /* construct source and dst sockaddrs. */
400 sockaddr_in_init(&src, &ip->ip_src, uh->uh_sport);
401 sockaddr_in_init(&dst, &ip->ip_dst, uh->uh_dport);
402
403 if ((n = udp4_realinput(&src, &dst, &m, iphlen)) == -1) {
404 UDP_STATINC(UDP_STAT_HDROPS);
405 return;
406 }
407 #ifdef INET6
408 if (IN_MULTICAST(ip->ip_dst.s_addr) || n == 0) {
409 struct sockaddr_in6 src6, dst6;
410
411 bzero(&src6, sizeof(src6));
412 src6.sin6_family = AF_INET6;
413 src6.sin6_len = sizeof(struct sockaddr_in6);
414 src6.sin6_addr.s6_addr[10] = src6.sin6_addr.s6_addr[11] = 0xff;
415 bcopy(&ip->ip_src, &src6.sin6_addr.s6_addr[12],
416 sizeof(ip->ip_src));
417 src6.sin6_port = uh->uh_sport;
418 bzero(&dst6, sizeof(dst6));
419 dst6.sin6_family = AF_INET6;
420 dst6.sin6_len = sizeof(struct sockaddr_in6);
421 dst6.sin6_addr.s6_addr[10] = dst6.sin6_addr.s6_addr[11] = 0xff;
422 bcopy(&ip->ip_dst, &dst6.sin6_addr.s6_addr[12],
423 sizeof(ip->ip_dst));
424 dst6.sin6_port = uh->uh_dport;
425
426 n += udp6_realinput(AF_INET, &src6, &dst6, m, iphlen);
427 }
428 #endif
429
430 if (n == 0) {
431 if (m->m_flags & (M_BCAST | M_MCAST)) {
432 UDP_STATINC(UDP_STAT_NOPORTBCAST);
433 goto bad;
434 }
435 UDP_STATINC(UDP_STAT_NOPORT);
436 #ifdef IPKDB
437 if (checkipkdb(&ip->ip_src, uh->uh_sport, uh->uh_dport,
438 m, iphlen + sizeof(struct udphdr),
439 m->m_pkthdr.len - iphlen - sizeof(struct udphdr))) {
440 /*
441 * It was a debugger connect packet,
442 * just drop it now
443 */
444 goto bad;
445 }
446 #endif
447 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0);
448 m = NULL;
449 }
450
451 bad:
452 if (m)
453 m_freem(m);
454 return;
455
456 badcsum:
457 m_freem(m);
458 }
459 #endif
460
461 #ifdef INET6
462 static int
463 udp6_input_checksum(struct mbuf *m, const struct udphdr *uh, int off, int len)
464 {
465
466 /*
467 * XXX it's better to record and check if this mbuf is
468 * already checked.
469 */
470
471 if (__predict_false((m->m_flags & M_LOOP) && !udp_do_loopback_cksum)) {
472 goto good;
473 }
474 if (uh->uh_sum == 0) {
475 UDP6_STATINC(UDP6_STAT_NOSUM);
476 goto bad;
477 }
478
479 switch (m->m_pkthdr.csum_flags &
480 ((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_UDPv6) |
481 M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
482 case M_CSUM_UDPv6|M_CSUM_TCP_UDP_BAD:
483 UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_bad);
484 UDP6_STATINC(UDP6_STAT_BADSUM);
485 goto bad;
486
487 #if 0 /* notyet */
488 case M_CSUM_UDPv6|M_CSUM_DATA:
489 #endif
490
491 case M_CSUM_UDPv6:
492 /* Checksum was okay. */
493 UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_ok);
494 break;
495
496 default:
497 /*
498 * Need to compute it ourselves. Maybe skip checksum
499 * on loopback interfaces.
500 */
501 UDP_CSUM_COUNTER_INCR(&udp6_swcsum);
502 if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {
503 UDP6_STATINC(UDP6_STAT_BADSUM);
504 goto bad;
505 }
506 }
507
508 good:
509 return 0;
510 bad:
511 return -1;
512 }
513
514 int
515 udp6_input(struct mbuf **mp, int *offp, int proto)
516 {
517 struct mbuf *m = *mp;
518 int off = *offp;
519 struct sockaddr_in6 src, dst;
520 struct ip6_hdr *ip6;
521 struct udphdr *uh;
522 u_int32_t plen, ulen;
523
524 ip6 = mtod(m, struct ip6_hdr *);
525
526 #if defined(NFAITH) && 0 < NFAITH
527 if (faithprefix(&ip6->ip6_dst)) {
528 /* send icmp6 host unreach? */
529 m_freem(m);
530 return IPPROTO_DONE;
531 }
532 #endif
533
534 UDP6_STATINC(UDP6_STAT_IPACKETS);
535
536 /* check for jumbogram is done in ip6_input. we can trust pkthdr.len */
537 plen = m->m_pkthdr.len - off;
538 IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));
539 if (uh == NULL) {
540 IP6_STATINC(IP6_STAT_TOOSHORT);
541 return IPPROTO_DONE;
542 }
543 KASSERT(UDP_HDR_ALIGNED_P(uh));
544 ulen = ntohs((u_short)uh->uh_ulen);
545 /*
546 * RFC2675 section 4: jumbograms will have 0 in the UDP header field,
547 * iff payload length > 0xffff.
548 */
549 if (ulen == 0 && plen > 0xffff)
550 ulen = plen;
551
552 if (plen != ulen) {
553 UDP6_STATINC(UDP6_STAT_BADLEN);
554 goto bad;
555 }
556
557 /* destination port of 0 is illegal, based on RFC768. */
558 if (uh->uh_dport == 0)
559 goto bad;
560
561 /* Be proactive about malicious use of IPv4 mapped address */
562 if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
563 IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
564 /* XXX stat */
565 goto bad;
566 }
567
568 /*
569 * Checksum extended UDP header and data. Maybe skip checksum
570 * on loopback interfaces.
571 */
572 if (udp6_input_checksum(m, uh, off, ulen))
573 goto bad;
574
575 /*
576 * Construct source and dst sockaddrs.
577 */
578 bzero(&src, sizeof(src));
579 src.sin6_family = AF_INET6;
580 src.sin6_len = sizeof(struct sockaddr_in6);
581 src.sin6_addr = ip6->ip6_src;
582 src.sin6_port = uh->uh_sport;
583 bzero(&dst, sizeof(dst));
584 dst.sin6_family = AF_INET6;
585 dst.sin6_len = sizeof(struct sockaddr_in6);
586 dst.sin6_addr = ip6->ip6_dst;
587 dst.sin6_port = uh->uh_dport;
588
589 if (udp6_realinput(AF_INET6, &src, &dst, m, off) == 0) {
590 if (m->m_flags & M_MCAST) {
591 UDP6_STATINC(UDP6_STAT_NOPORTMCAST);
592 goto bad;
593 }
594 UDP6_STATINC(UDP6_STAT_NOPORT);
595 icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
596 m = NULL;
597 }
598
599 bad:
600 if (m)
601 m_freem(m);
602 return IPPROTO_DONE;
603 }
604 #endif
605
606 #ifdef INET
607 static void
608 udp4_sendup(struct mbuf *m, int off /* offset of data portion */,
609 struct sockaddr *src, struct socket *so)
610 {
611 struct mbuf *opts = NULL;
612 struct mbuf *n;
613 struct inpcb *inp = NULL;
614
615 if (!so)
616 return;
617 switch (so->so_proto->pr_domain->dom_family) {
618 case AF_INET:
619 inp = sotoinpcb(so);
620 break;
621 #ifdef INET6
622 case AF_INET6:
623 break;
624 #endif
625 default:
626 return;
627 }
628
629 #if defined(IPSEC) || defined(FAST_IPSEC)
630 /* check AH/ESP integrity. */
631 if (so != NULL && ipsec4_in_reject_so(m, so)) {
632 IPSEC_STATINC(IPSEC_STAT_IN_POLVIO);
633 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
634 icmp_error(n, ICMP_UNREACH, ICMP_UNREACH_ADMIN_PROHIBIT,
635 0, 0);
636 return;
637 }
638 #endif /*IPSEC*/
639
640 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL) {
641 if (inp && (inp->inp_flags & INP_CONTROLOPTS
642 || so->so_options & SO_TIMESTAMP)) {
643 struct ip *ip = mtod(n, struct ip *);
644 ip_savecontrol(inp, &opts, ip, n);
645 }
646
647 m_adj(n, off);
648 if (sbappendaddr(&so->so_rcv, src, n,
649 opts) == 0) {
650 m_freem(n);
651 if (opts)
652 m_freem(opts);
653 so->so_rcv.sb_overflowed++;
654 UDP_STATINC(UDP_STAT_FULLSOCK);
655 } else
656 sorwakeup(so);
657 }
658 }
659 #endif
660
661 #ifdef INET6
662 static void
663 udp6_sendup(struct mbuf *m, int off /* offset of data portion */,
664 struct sockaddr *src, struct socket *so)
665 {
666 struct mbuf *opts = NULL;
667 struct mbuf *n;
668 struct in6pcb *in6p = NULL;
669
670 if (!so)
671 return;
672 if (so->so_proto->pr_domain->dom_family != AF_INET6)
673 return;
674 in6p = sotoin6pcb(so);
675
676 #if defined(IPSEC) || defined(FAST_IPSEC)
677 /* check AH/ESP integrity. */
678 if (so != NULL && ipsec6_in_reject_so(m, so)) {
679 IPSEC6_STATINC(IPSEC_STAT_IN_POLVIO);
680 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
681 icmp6_error(n, ICMP6_DST_UNREACH,
682 ICMP6_DST_UNREACH_ADMIN, 0);
683 return;
684 }
685 #endif /*IPSEC*/
686
687 if ((n = m_copypacket(m, M_DONTWAIT)) != NULL) {
688 if (in6p && (in6p->in6p_flags & IN6P_CONTROLOPTS
689 || in6p->in6p_socket->so_options & SO_TIMESTAMP)) {
690 struct ip6_hdr *ip6 = mtod(n, struct ip6_hdr *);
691 ip6_savecontrol(in6p, &opts, ip6, n);
692 }
693
694 m_adj(n, off);
695 if (sbappendaddr(&so->so_rcv, src, n, opts) == 0) {
696 m_freem(n);
697 if (opts)
698 m_freem(opts);
699 so->so_rcv.sb_overflowed++;
700 UDP6_STATINC(UDP6_STAT_FULLSOCK);
701 } else
702 sorwakeup(so);
703 }
704 }
705 #endif
706
707 #ifdef INET
708 static int
709 udp4_realinput(struct sockaddr_in *src, struct sockaddr_in *dst,
710 struct mbuf **mp, int off /* offset of udphdr */)
711 {
712 u_int16_t *sport, *dport;
713 int rcvcnt;
714 struct in_addr *src4, *dst4;
715 struct inpcb_hdr *inph;
716 struct inpcb *inp;
717 struct mbuf *m = *mp;
718
719 rcvcnt = 0;
720 off += sizeof(struct udphdr); /* now, offset of payload */
721
722 if (src->sin_family != AF_INET || dst->sin_family != AF_INET)
723 goto bad;
724
725 src4 = &src->sin_addr;
726 sport = &src->sin_port;
727 dst4 = &dst->sin_addr;
728 dport = &dst->sin_port;
729
730 if (IN_MULTICAST(dst4->s_addr) ||
731 in_broadcast(*dst4, m->m_pkthdr.rcvif)) {
732 /*
733 * Deliver a multicast or broadcast datagram to *all* sockets
734 * for which the local and remote addresses and ports match
735 * those of the incoming datagram. This allows more than
736 * one process to receive multi/broadcasts on the same port.
737 * (This really ought to be done for unicast datagrams as
738 * well, but that would cause problems with existing
739 * applications that open both address-specific sockets and
740 * a wildcard socket listening to the same port -- they would
741 * end up receiving duplicates of every unicast datagram.
742 * Those applications open the multiple sockets to overcome an
743 * inadequacy of the UDP socket interface, but for backwards
744 * compatibility we avoid the problem here rather than
745 * fixing the interface. Maybe 4.5BSD will remedy this?)
746 */
747
748 /*
749 * KAME note: traditionally we dropped udpiphdr from mbuf here.
750 * we need udpiphdr for IPsec processing so we do that later.
751 */
752 /*
753 * Locate pcb(s) for datagram.
754 */
755 CIRCLEQ_FOREACH(inph, &udbtable.inpt_queue, inph_queue) {
756 inp = (struct inpcb *)inph;
757 if (inp->inp_af != AF_INET)
758 continue;
759
760 if (inp->inp_lport != *dport)
761 continue;
762 if (!in_nullhost(inp->inp_laddr)) {
763 if (!in_hosteq(inp->inp_laddr, *dst4))
764 continue;
765 }
766 if (!in_nullhost(inp->inp_faddr)) {
767 if (!in_hosteq(inp->inp_faddr, *src4) ||
768 inp->inp_fport != *sport)
769 continue;
770 }
771
772 udp4_sendup(m, off, (struct sockaddr *)src,
773 inp->inp_socket);
774 rcvcnt++;
775
776 /*
777 * Don't look for additional matches if this one does
778 * not have either the SO_REUSEPORT or SO_REUSEADDR
779 * socket options set. This heuristic avoids searching
780 * through all pcbs in the common case of a non-shared
781 * port. It assumes that an application will never
782 * clear these options after setting them.
783 */
784 if ((inp->inp_socket->so_options &
785 (SO_REUSEPORT|SO_REUSEADDR)) == 0)
786 break;
787 }
788 } else {
789 /*
790 * Locate pcb for datagram.
791 */
792 inp = in_pcblookup_connect(&udbtable, *src4, *sport, *dst4, *dport);
793 if (inp == 0) {
794 UDP_STATINC(UDP_STAT_PCBHASHMISS);
795 inp = in_pcblookup_bind(&udbtable, *dst4, *dport);
796 if (inp == 0)
797 return rcvcnt;
798 }
799
800 #ifdef IPSEC_NAT_T
801 /* Handle ESP over UDP */
802 if (inp->inp_flags & INP_ESPINUDP_ALL) {
803 struct sockaddr *sa = (struct sockaddr *)src;
804
805 switch(udp4_espinudp(mp, off, sa, inp->inp_socket)) {
806 case -1: /* Error, m was freeed */
807 rcvcnt = -1;
808 goto bad;
809 break;
810
811 case 1: /* ESP over UDP */
812 rcvcnt++;
813 goto bad;
814 break;
815
816 case 0: /* plain UDP */
817 default: /* Unexpected */
818 /*
819 * Normal UDP processing will take place
820 * m may have changed.
821 */
822 m = *mp;
823 break;
824 }
825 }
826 #endif
827
828 udp4_sendup(m, off, (struct sockaddr *)src, inp->inp_socket);
829 rcvcnt++;
830 }
831
832 bad:
833 return rcvcnt;
834 }
835 #endif
836
837 #ifdef INET6
838 static int
839 udp6_realinput(int af, struct sockaddr_in6 *src, struct sockaddr_in6 *dst,
840 struct mbuf *m, int off)
841 {
842 u_int16_t sport, dport;
843 int rcvcnt;
844 struct in6_addr src6, *dst6;
845 const struct in_addr *dst4;
846 struct inpcb_hdr *inph;
847 struct in6pcb *in6p;
848
849 rcvcnt = 0;
850 off += sizeof(struct udphdr); /* now, offset of payload */
851
852 if (af != AF_INET && af != AF_INET6)
853 goto bad;
854 if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)
855 goto bad;
856
857 src6 = src->sin6_addr;
858 if (sa6_recoverscope(src) != 0) {
859 /* XXX: should be impossible. */
860 goto bad;
861 }
862 sport = src->sin6_port;
863
864 dport = dst->sin6_port;
865 dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[12];
866 dst6 = &dst->sin6_addr;
867
868 if (IN6_IS_ADDR_MULTICAST(dst6) ||
869 (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {
870 /*
871 * Deliver a multicast or broadcast datagram to *all* sockets
872 * for which the local and remote addresses and ports match
873 * those of the incoming datagram. This allows more than
874 * one process to receive multi/broadcasts on the same port.
875 * (This really ought to be done for unicast datagrams as
876 * well, but that would cause problems with existing
877 * applications that open both address-specific sockets and
878 * a wildcard socket listening to the same port -- they would
879 * end up receiving duplicates of every unicast datagram.
880 * Those applications open the multiple sockets to overcome an
881 * inadequacy of the UDP socket interface, but for backwards
882 * compatibility we avoid the problem here rather than
883 * fixing the interface. Maybe 4.5BSD will remedy this?)
884 */
885
886 /*
887 * KAME note: traditionally we dropped udpiphdr from mbuf here.
888 * we need udpiphdr for IPsec processing so we do that later.
889 */
890 /*
891 * Locate pcb(s) for datagram.
892 */
893 CIRCLEQ_FOREACH(inph, &udbtable.inpt_queue, inph_queue) {
894 in6p = (struct in6pcb *)inph;
895 if (in6p->in6p_af != AF_INET6)
896 continue;
897
898 if (in6p->in6p_lport != dport)
899 continue;
900 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {
901 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr,
902 dst6))
903 continue;
904 } else {
905 if (IN6_IS_ADDR_V4MAPPED(dst6) &&
906 (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
907 continue;
908 }
909 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
910 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr,
911 &src6) || in6p->in6p_fport != sport)
912 continue;
913 } else {
914 if (IN6_IS_ADDR_V4MAPPED(&src6) &&
915 (in6p->in6p_flags & IN6P_IPV6_V6ONLY))
916 continue;
917 }
918
919 udp6_sendup(m, off, (struct sockaddr *)src,
920 in6p->in6p_socket);
921 rcvcnt++;
922
923 /*
924 * Don't look for additional matches if this one does
925 * not have either the SO_REUSEPORT or SO_REUSEADDR
926 * socket options set. This heuristic avoids searching
927 * through all pcbs in the common case of a non-shared
928 * port. It assumes that an application will never
929 * clear these options after setting them.
930 */
931 if ((in6p->in6p_socket->so_options &
932 (SO_REUSEPORT|SO_REUSEADDR)) == 0)
933 break;
934 }
935 } else {
936 /*
937 * Locate pcb for datagram.
938 */
939 in6p = in6_pcblookup_connect(&udbtable, &src6, sport, dst6,
940 dport, 0);
941 if (in6p == 0) {
942 UDP_STATINC(UDP_STAT_PCBHASHMISS);
943 in6p = in6_pcblookup_bind(&udbtable, dst6, dport, 0);
944 if (in6p == 0)
945 return rcvcnt;
946 }
947
948 udp6_sendup(m, off, (struct sockaddr *)src, in6p->in6p_socket);
949 rcvcnt++;
950 }
951
952 bad:
953 return rcvcnt;
954 }
955 #endif
956
957 #ifdef INET
958 /*
959 * Notify a udp user of an asynchronous error;
960 * just wake up so that he can collect error status.
961 */
962 static void
963 udp_notify(struct inpcb *inp, int errno)
964 {
965 inp->inp_socket->so_error = errno;
966 sorwakeup(inp->inp_socket);
967 sowwakeup(inp->inp_socket);
968 }
969
970 void *
971 udp_ctlinput(int cmd, const struct sockaddr *sa, void *v)
972 {
973 struct ip *ip = v;
974 struct udphdr *uh;
975 void (*notify)(struct inpcb *, int) = udp_notify;
976 int errno;
977
978 if (sa->sa_family != AF_INET
979 || sa->sa_len != sizeof(struct sockaddr_in))
980 return NULL;
981 if ((unsigned)cmd >= PRC_NCMDS)
982 return NULL;
983 errno = inetctlerrmap[cmd];
984 if (PRC_IS_REDIRECT(cmd))
985 notify = in_rtchange, ip = 0;
986 else if (cmd == PRC_HOSTDEAD)
987 ip = 0;
988 else if (errno == 0)
989 return NULL;
990 if (ip) {
991 uh = (struct udphdr *)((char *)ip + (ip->ip_hl << 2));
992 in_pcbnotify(&udbtable, satocsin(sa)->sin_addr, uh->uh_dport,
993 ip->ip_src, uh->uh_sport, errno, notify);
994
995 /* XXX mapped address case */
996 } else
997 in_pcbnotifyall(&udbtable, satocsin(sa)->sin_addr, errno,
998 notify);
999 return NULL;
1000 }
1001
1002 int
1003 udp_ctloutput(int op, struct socket *so, struct sockopt *sopt)
1004 {
1005 int s;
1006 int error = 0;
1007 struct inpcb *inp;
1008 int family;
1009 int optval;
1010
1011 family = so->so_proto->pr_domain->dom_family;
1012
1013 s = splsoftnet();
1014 switch (family) {
1015 #ifdef INET
1016 case PF_INET:
1017 if (sopt->sopt_level != IPPROTO_UDP) {
1018 error = ip_ctloutput(op, so, sopt);
1019 goto end;
1020 }
1021 break;
1022 #endif
1023 #ifdef INET6
1024 case PF_INET6:
1025 if (sopt->sopt_level != IPPROTO_UDP) {
1026 error = ip6_ctloutput(op, so, sopt);
1027 goto end;
1028 }
1029 break;
1030 #endif
1031 default:
1032 error = EAFNOSUPPORT;
1033 goto end;
1034 }
1035
1036
1037 switch (op) {
1038 case PRCO_SETOPT:
1039 inp = sotoinpcb(so);
1040
1041 switch (sopt->sopt_name) {
1042 case UDP_ENCAP:
1043 error = sockopt_getint(sopt, &optval);
1044 if (error)
1045 break;
1046
1047 switch(optval) {
1048 #ifdef IPSEC_NAT_T
1049 case 0:
1050 inp->inp_flags &= ~INP_ESPINUDP_ALL;
1051 break;
1052
1053 case UDP_ENCAP_ESPINUDP:
1054 inp->inp_flags &= ~INP_ESPINUDP_ALL;
1055 inp->inp_flags |= INP_ESPINUDP;
1056 break;
1057
1058 case UDP_ENCAP_ESPINUDP_NON_IKE:
1059 inp->inp_flags &= ~INP_ESPINUDP_ALL;
1060 inp->inp_flags |= INP_ESPINUDP_NON_IKE;
1061 break;
1062 #endif
1063 default:
1064 error = EINVAL;
1065 break;
1066 }
1067 break;
1068
1069 default:
1070 error = ENOPROTOOPT;
1071 break;
1072 }
1073 break;
1074
1075 default:
1076 error = EINVAL;
1077 break;
1078 }
1079
1080 end:
1081 splx(s);
1082 return error;
1083 }
1084
1085
1086 int
1087 udp_output(struct mbuf *m, ...)
1088 {
1089 struct inpcb *inp;
1090 struct udpiphdr *ui;
1091 struct route *ro;
1092 int len = m->m_pkthdr.len;
1093 int error = 0;
1094 va_list ap;
1095
1096 MCLAIM(m, &udp_tx_mowner);
1097 va_start(ap, m);
1098 inp = va_arg(ap, struct inpcb *);
1099 va_end(ap);
1100
1101 /*
1102 * Calculate data length and get a mbuf
1103 * for UDP and IP headers.
1104 */
1105 M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT);
1106 if (m == 0) {
1107 error = ENOBUFS;
1108 goto release;
1109 }
1110
1111 /*
1112 * Compute the packet length of the IP header, and
1113 * punt if the length looks bogus.
1114 */
1115 if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) {
1116 error = EMSGSIZE;
1117 goto release;
1118 }
1119
1120 /*
1121 * Fill in mbuf with extended UDP header
1122 * and addresses and length put into network format.
1123 */
1124 ui = mtod(m, struct udpiphdr *);
1125 ui->ui_pr = IPPROTO_UDP;
1126 ui->ui_src = inp->inp_laddr;
1127 ui->ui_dst = inp->inp_faddr;
1128 ui->ui_sport = inp->inp_lport;
1129 ui->ui_dport = inp->inp_fport;
1130 ui->ui_ulen = htons((u_int16_t)len + sizeof(struct udphdr));
1131
1132 ro = &inp->inp_route;
1133
1134 /*
1135 * Set up checksum and output datagram.
1136 */
1137 if (udpcksum) {
1138 /*
1139 * XXX Cache pseudo-header checksum part for
1140 * XXX "connected" UDP sockets.
1141 */
1142 ui->ui_sum = in_cksum_phdr(ui->ui_src.s_addr,
1143 ui->ui_dst.s_addr, htons((u_int16_t)len +
1144 sizeof(struct udphdr) + IPPROTO_UDP));
1145 m->m_pkthdr.csum_flags = M_CSUM_UDPv4;
1146 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
1147 } else
1148 ui->ui_sum = 0;
1149 ((struct ip *)ui)->ip_len = htons(sizeof (struct udpiphdr) + len);
1150 ((struct ip *)ui)->ip_ttl = inp->inp_ip.ip_ttl; /* XXX */
1151 ((struct ip *)ui)->ip_tos = inp->inp_ip.ip_tos; /* XXX */
1152 UDP_STATINC(UDP_STAT_OPACKETS);
1153
1154 return (ip_output(m, inp->inp_options, ro,
1155 inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST),
1156 inp->inp_moptions, inp->inp_socket));
1157
1158 release:
1159 m_freem(m);
1160 return (error);
1161 }
1162
1163 int udp_sendspace = 9216; /* really max datagram size */
1164 int udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
1165 /* 40 1K datagrams */
1166
1167 /*ARGSUSED*/
1168 int
1169 udp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
1170 struct mbuf *control, struct lwp *l)
1171 {
1172 struct inpcb *inp;
1173 int s;
1174 int error = 0;
1175
1176 if (req == PRU_CONTROL)
1177 return (in_control(so, (long)m, (void *)nam,
1178 (struct ifnet *)control, l));
1179
1180 s = splsoftnet();
1181
1182 if (req == PRU_PURGEIF) {
1183 mutex_enter(softnet_lock);
1184 in_pcbpurgeif0(&udbtable, (struct ifnet *)control);
1185 in_purgeif((struct ifnet *)control);
1186 in_pcbpurgeif(&udbtable, (struct ifnet *)control);
1187 mutex_exit(softnet_lock);
1188 splx(s);
1189 return (0);
1190 }
1191
1192 inp = sotoinpcb(so);
1193 #ifdef DIAGNOSTIC
1194 if (req != PRU_SEND && req != PRU_SENDOOB && control)
1195 panic("udp_usrreq: unexpected control mbuf");
1196 #endif
1197 if (req == PRU_ATTACH) {
1198 sosetlock(so);
1199 } else if (inp == 0) {
1200 error = EINVAL;
1201 goto release;
1202 }
1203
1204 /*
1205 * Note: need to block udp_input while changing
1206 * the udp pcb queue and/or pcb addresses.
1207 */
1208 switch (req) {
1209
1210 case PRU_ATTACH:
1211 if (inp != 0) {
1212 error = EISCONN;
1213 break;
1214 }
1215 #ifdef MBUFTRACE
1216 so->so_mowner = &udp_mowner;
1217 so->so_rcv.sb_mowner = &udp_rx_mowner;
1218 so->so_snd.sb_mowner = &udp_tx_mowner;
1219 #endif
1220 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
1221 error = soreserve(so, udp_sendspace, udp_recvspace);
1222 if (error)
1223 break;
1224 }
1225 error = in_pcballoc(so, &udbtable);
1226 if (error)
1227 break;
1228 inp = sotoinpcb(so);
1229 inp->inp_ip.ip_ttl = ip_defttl;
1230 break;
1231
1232 case PRU_DETACH:
1233 in_pcbdetach(inp);
1234 break;
1235
1236 case PRU_BIND:
1237 error = in_pcbbind(inp, nam, l);
1238 break;
1239
1240 case PRU_LISTEN:
1241 error = EOPNOTSUPP;
1242 break;
1243
1244 case PRU_CONNECT:
1245 error = in_pcbconnect(inp, nam, l);
1246 if (error)
1247 break;
1248 soisconnected(so);
1249 break;
1250
1251 case PRU_CONNECT2:
1252 error = EOPNOTSUPP;
1253 break;
1254
1255 case PRU_DISCONNECT:
1256 /*soisdisconnected(so);*/
1257 so->so_state &= ~SS_ISCONNECTED; /* XXX */
1258 in_pcbdisconnect(inp);
1259 inp->inp_laddr = zeroin_addr; /* XXX */
1260 in_pcbstate(inp, INP_BOUND); /* XXX */
1261 break;
1262
1263 case PRU_SHUTDOWN:
1264 socantsendmore(so);
1265 break;
1266
1267 case PRU_RCVD:
1268 error = EOPNOTSUPP;
1269 break;
1270
1271 case PRU_SEND:
1272 if (control && control->m_len) {
1273 m_freem(control);
1274 m_freem(m);
1275 error = EINVAL;
1276 break;
1277 }
1278 {
1279 struct in_addr laddr; /* XXX */
1280
1281 if (nam) {
1282 laddr = inp->inp_laddr; /* XXX */
1283 if ((so->so_state & SS_ISCONNECTED) != 0) {
1284 error = EISCONN;
1285 goto die;
1286 }
1287 error = in_pcbconnect(inp, nam, l);
1288 if (error)
1289 goto die;
1290 } else {
1291 if ((so->so_state & SS_ISCONNECTED) == 0) {
1292 error = ENOTCONN;
1293 goto die;
1294 }
1295 }
1296 error = udp_output(m, inp);
1297 m = NULL;
1298 if (nam) {
1299 in_pcbdisconnect(inp);
1300 inp->inp_laddr = laddr; /* XXX */
1301 in_pcbstate(inp, INP_BOUND); /* XXX */
1302 }
1303 die:
1304 if (m)
1305 m_freem(m);
1306 }
1307 break;
1308
1309 case PRU_SENSE:
1310 /*
1311 * stat: don't bother with a blocksize.
1312 */
1313 splx(s);
1314 return (0);
1315
1316 case PRU_RCVOOB:
1317 error = EOPNOTSUPP;
1318 break;
1319
1320 case PRU_SENDOOB:
1321 m_freem(control);
1322 m_freem(m);
1323 error = EOPNOTSUPP;
1324 break;
1325
1326 case PRU_SOCKADDR:
1327 in_setsockaddr(inp, nam);
1328 break;
1329
1330 case PRU_PEERADDR:
1331 in_setpeeraddr(inp, nam);
1332 break;
1333
1334 default:
1335 panic("udp_usrreq");
1336 }
1337
1338 release:
1339 splx(s);
1340 return (error);
1341 }
1342
1343 static int
1344 sysctl_net_inet_udp_stats(SYSCTLFN_ARGS)
1345 {
1346
1347 return (NETSTAT_SYSCTL(udpstat_percpu, UDP_NSTATS));
1348 }
1349
1350 /*
1351 * Sysctl for udp variables.
1352 */
1353 SYSCTL_SETUP(sysctl_net_inet_udp_setup, "sysctl net.inet.udp subtree setup")
1354 {
1355
1356 sysctl_createv(clog, 0, NULL, NULL,
1357 CTLFLAG_PERMANENT,
1358 CTLTYPE_NODE, "net", NULL,
1359 NULL, 0, NULL, 0,
1360 CTL_NET, CTL_EOL);
1361 sysctl_createv(clog, 0, NULL, NULL,
1362 CTLFLAG_PERMANENT,
1363 CTLTYPE_NODE, "inet", NULL,
1364 NULL, 0, NULL, 0,
1365 CTL_NET, PF_INET, CTL_EOL);
1366 sysctl_createv(clog, 0, NULL, NULL,
1367 CTLFLAG_PERMANENT,
1368 CTLTYPE_NODE, "udp",
1369 SYSCTL_DESCR("UDPv4 related settings"),
1370 NULL, 0, NULL, 0,
1371 CTL_NET, PF_INET, IPPROTO_UDP, CTL_EOL);
1372
1373 sysctl_createv(clog, 0, NULL, NULL,
1374 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1375 CTLTYPE_INT, "checksum",
1376 SYSCTL_DESCR("Compute UDP checksums"),
1377 NULL, 0, &udpcksum, 0,
1378 CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_CHECKSUM,
1379 CTL_EOL);
1380 sysctl_createv(clog, 0, NULL, NULL,
1381 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1382 CTLTYPE_INT, "sendspace",
1383 SYSCTL_DESCR("Default UDP send buffer size"),
1384 NULL, 0, &udp_sendspace, 0,
1385 CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_SENDSPACE,
1386 CTL_EOL);
1387 sysctl_createv(clog, 0, NULL, NULL,
1388 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1389 CTLTYPE_INT, "recvspace",
1390 SYSCTL_DESCR("Default UDP receive buffer size"),
1391 NULL, 0, &udp_recvspace, 0,
1392 CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_RECVSPACE,
1393 CTL_EOL);
1394 sysctl_createv(clog, 0, NULL, NULL,
1395 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
1396 CTLTYPE_INT, "do_loopback_cksum",
1397 SYSCTL_DESCR("Perform UDP checksum on loopback"),
1398 NULL, 0, &udp_do_loopback_cksum, 0,
1399 CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_LOOPBACKCKSUM,
1400 CTL_EOL);
1401 sysctl_createv(clog, 0, NULL, NULL,
1402 CTLFLAG_PERMANENT,
1403 CTLTYPE_STRUCT, "pcblist",
1404 SYSCTL_DESCR("UDP protocol control block list"),
1405 sysctl_inpcblist, 0, &udbtable, 0,
1406 CTL_NET, PF_INET, IPPROTO_UDP, CTL_CREATE,
1407 CTL_EOL);
1408 sysctl_createv(clog, 0, NULL, NULL,
1409 CTLFLAG_PERMANENT,
1410 CTLTYPE_STRUCT, "stats",
1411 SYSCTL_DESCR("UDP statistics"),
1412 sysctl_net_inet_udp_stats, 0, NULL, 0,
1413 CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_STATS,
1414 CTL_EOL);
1415 }
1416 #endif
1417
1418 void
1419 udp_statinc(u_int stat)
1420 {
1421
1422 KASSERT(stat < UDP_NSTATS);
1423 UDP_STATINC(stat);
1424 }
1425
1426 #if (defined INET && defined IPSEC_NAT_T)
1427 /*
1428 * Returns:
1429 * 1 if the packet was processed
1430 * 0 if normal UDP processing should take place
1431 * -1 if an error occurent and m was freed
1432 */
1433 static int
1434 udp4_espinudp(struct mbuf **mp, int off, struct sockaddr *src,
1435 struct socket *so)
1436 {
1437 size_t len;
1438 void *data;
1439 struct inpcb *inp;
1440 size_t skip = 0;
1441 size_t minlen;
1442 size_t iphdrlen;
1443 struct ip *ip;
1444 struct mbuf *n;
1445 struct m_tag *tag;
1446 struct udphdr *udphdr;
1447 u_int16_t sport, dport;
1448 struct mbuf *m = *mp;
1449
1450 /*
1451 * Collapse the mbuf chain if the first mbuf is too short
1452 * The longest case is: UDP + non ESP marker + ESP
1453 */
1454 minlen = off + sizeof(u_int64_t) + sizeof(struct esp);
1455 if (minlen > m->m_pkthdr.len)
1456 minlen = m->m_pkthdr.len;
1457
1458 if (m->m_len < minlen) {
1459 if ((*mp = m_pullup(m, minlen)) == NULL) {
1460 printf("udp4_espinudp: m_pullup failed\n");
1461 return -1;
1462 }
1463 m = *mp;
1464 }
1465
1466 len = m->m_len - off;
1467 data = mtod(m, char *) + off;
1468 inp = sotoinpcb(so);
1469
1470 /* Ignore keepalive packets */
1471 if ((len == 1) && (*(unsigned char *)data == 0xff)) {
1472 return 1;
1473 }
1474
1475 /*
1476 * Check that the payload is long enough to hold
1477 * an ESP header and compute the length of encapsulation
1478 * header to remove
1479 */
1480 if (inp->inp_flags & INP_ESPINUDP) {
1481 u_int32_t *st = (u_int32_t *)data;
1482
1483 if ((len <= sizeof(struct esp)) || (*st == 0))
1484 return 0; /* Normal UDP processing */
1485
1486 skip = sizeof(struct udphdr);
1487 }
1488
1489 if (inp->inp_flags & INP_ESPINUDP_NON_IKE) {
1490 u_int32_t *st = (u_int32_t *)data;
1491
1492 if ((len <= sizeof(u_int64_t) + sizeof(struct esp))
1493 || ((st[0] | st[1]) != 0))
1494 return 0; /* Normal UDP processing */
1495
1496 skip = sizeof(struct udphdr) + sizeof(u_int64_t);
1497 }
1498
1499 /*
1500 * Get the UDP ports. They are handled in network
1501 * order everywhere in IPSEC_NAT_T code.
1502 */
1503 udphdr = (struct udphdr *)((char *)data - skip);
1504 sport = udphdr->uh_sport;
1505 dport = udphdr->uh_dport;
1506
1507 /*
1508 * Remove the UDP header (and possibly the non ESP marker)
1509 * IP header lendth is iphdrlen
1510 * Before:
1511 * <--- off --->
1512 * +----+------+-----+
1513 * | IP | UDP | ESP |
1514 * +----+------+-----+
1515 * <-skip->
1516 * After:
1517 * +----+-----+
1518 * | IP | ESP |
1519 * +----+-----+
1520 * <-skip->
1521 */
1522 iphdrlen = off - sizeof(struct udphdr);
1523 memmove(mtod(m, char *) + skip, mtod(m, void *), iphdrlen);
1524 m_adj(m, skip);
1525
1526 ip = mtod(m, struct ip *);
1527 ip->ip_len = htons(ntohs(ip->ip_len) - skip);
1528 ip->ip_p = IPPROTO_ESP;
1529
1530 /*
1531 * Copy the mbuf to avoid multiple free, as both
1532 * esp4_input (which we call) and udp_input (which
1533 * called us) free the mbuf.
1534 */
1535 if ((n = m_dup(m, 0, M_COPYALL, M_DONTWAIT)) == NULL) {
1536 printf("udp4_espinudp: m_dup failed\n");
1537 return 0;
1538 }
1539
1540 /*
1541 * Add a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember
1542 * the source UDP port. This is required if we want
1543 * to select the right SPD for multiple hosts behind
1544 * same NAT
1545 */
1546 if ((tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,
1547 sizeof(sport) + sizeof(dport), M_DONTWAIT)) == NULL) {
1548 printf("udp4_espinudp: m_tag_get failed\n");
1549 m_freem(n);
1550 return 0;
1551 }
1552 ((u_int16_t *)(tag + 1))[0] = sport;
1553 ((u_int16_t *)(tag + 1))[1] = dport;
1554 m_tag_prepend(n, tag);
1555
1556 #ifdef FAST_IPSEC
1557 ipsec4_common_input(n, iphdrlen, IPPROTO_ESP);
1558 #else
1559 esp4_input(n, iphdrlen);
1560 #endif
1561
1562 /* We handled it, it shoudln't be handled by UDP */
1563 return 1;
1564 }
1565 #endif
Cache object: 8b8de43f8c933cf4db9204c07b19d5b7
|