![[BACK]](/icons/back.gif){kind=icon}
Return to udp_usrreq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet|
Return to udp_usrreq.c CVS log | Up to [local] / sys / netinet |
1.1 nbrk 1: /* $OpenBSD: udp_usrreq.c,v 1.114 2007/06/11 11:29:35 henning Exp $ */
2: /* $NetBSD: udp_usrreq.c,v 1.28 1996/03/16 23:54:03 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1988, 1990, 1993
6: * The Regents of the University of California. 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 University 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 REGENTS 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 REGENTS 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: * @(#)COPYRIGHT 1.1 (NRL) 17 January 1995
33: *
34: * NRL grants permission for redistribution and use in source and binary
35: * forms, with or without modification, of the software and documentation
36: * created at NRL provided that the following conditions are met:
37: *
38: * 1. Redistributions of source code must retain the above copyright
39: * notice, this list of conditions and the following disclaimer.
40: * 2. Redistributions in binary form must reproduce the above copyright
41: * notice, this list of conditions and the following disclaimer in the
42: * documentation and/or other materials provided with the distribution.
43: * 3. All advertising materials mentioning features or use of this software
44: * must display the following acknowledgements:
45: * This product includes software developed by the University of
46: * California, Berkeley and its contributors.
47: * This product includes software developed at the Information
48: * Technology Division, US Naval Research Laboratory.
49: * 4. Neither the name of the NRL nor the names of its contributors
50: * may be used to endorse or promote products derived from this software
51: * without specific prior written permission.
52: *
53: * THE SOFTWARE PROVIDED BY NRL IS PROVIDED BY NRL AND CONTRIBUTORS ``AS
54: * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
56: * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NRL OR
57: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
58: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
59: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
60: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
61: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
62: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
63: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64: *
65: * The views and conclusions contained in the software and documentation
66: * are those of the authors and should not be interpreted as representing
67: * official policies, either expressed or implied, of the US Naval
68: * Research Laboratory (NRL).
69: */
70:
71: #include <sys/param.h>
72: #include <sys/systm.h>
73: #include <sys/mbuf.h>
74: #include <sys/protosw.h>
75: #include <sys/socket.h>
76: #include <sys/socketvar.h>
77: #include <sys/sysctl.h>
78:
79: #include <net/if.h>
80: #include <net/route.h>
81:
82: #include <netinet/in.h>
83: #include <netinet/in_systm.h>
84: #include <netinet/in_var.h>
85: #include <netinet/ip.h>
86: #include <netinet/in_pcb.h>
87: #include <netinet/ip_var.h>
88: #include <netinet/ip_icmp.h>
89: #include <netinet/udp.h>
90: #include <netinet/udp_var.h>
91:
92: #ifdef IPSEC
93: #include <netinet/ip_ipsp.h>
94: #include <netinet/ip_esp.h>
95: #endif
96:
97: #ifdef INET6
98: #ifndef INET
99: #include <netinet/in.h>
100: #endif
101: #include <netinet6/ip6protosw.h>
102:
103: extern int ip6_defhlim;
104: #endif /* INET6 */
105:
106: /*
107: * UDP protocol implementation.
108: * Per RFC 768, August, 1980.
109: */
110: int udpcksum = 1;
111:
112: u_int udp_sendspace = 9216; /* really max datagram size */
113: u_int udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
114: /* 40 1K datagrams */
115:
116: int *udpctl_vars[UDPCTL_MAXID] = UDPCTL_VARS;
117:
118: struct inpcbtable udbtable;
119: struct udpstat udpstat;
120:
121: void udp_detach(struct inpcb *);
122: void udp_notify(struct inpcb *, int);
123:
124: #ifndef UDBHASHSIZE
125: #define UDBHASHSIZE 128
126: #endif
127: int udbhashsize = UDBHASHSIZE;
128:
129: /* from in_pcb.c */
130: extern struct baddynamicports baddynamicports;
131:
132: void
133: udp_init()
134: {
135: in_pcbinit(&udbtable, udbhashsize);
136: }
137:
138: #ifdef INET6
139: int
140: udp6_input(mp, offp, proto)
141: struct mbuf **mp;
142: int *offp, proto;
143: {
144: struct mbuf *m = *mp;
145:
146: #if defined(NFAITH) && 0 < NFAITH
147: if (m->m_pkthdr.rcvif) {
148: if (m->m_pkthdr.rcvif->if_type == IFT_FAITH) {
149: /* XXX send icmp6 host/port unreach? */
150: m_freem(m);
151: return IPPROTO_DONE;
152: }
153: }
154: #endif
155:
156: udp_input(m, *offp, proto);
157: return IPPROTO_DONE;
158: }
159: #endif
160:
161: void
162: udp_input(struct mbuf *m, ...)
163: {
164: struct ip *ip;
165: struct udphdr *uh;
166: struct inpcb *inp;
167: struct mbuf *opts = NULL;
168: struct ip save_ip;
169: int iphlen, len;
170: va_list ap;
171: u_int16_t savesum;
172: union {
173: struct sockaddr sa;
174: struct sockaddr_in sin;
175: #ifdef INET6
176: struct sockaddr_in6 sin6;
177: #endif /* INET6 */
178: } srcsa, dstsa;
179: #ifdef INET6
180: struct ip6_hdr *ip6;
181: #endif /* INET6 */
182: #ifdef IPSEC
183: struct m_tag *mtag;
184: struct tdb_ident *tdbi;
185: struct tdb *tdb;
186: int error, s;
187: #endif /* IPSEC */
188:
189: va_start(ap, m);
190: iphlen = va_arg(ap, int);
191: va_end(ap);
192:
193: udpstat.udps_ipackets++;
194:
195: switch (mtod(m, struct ip *)->ip_v) {
196: case 4:
197: ip = mtod(m, struct ip *);
198: #ifdef INET6
199: ip6 = NULL;
200: #endif /* INET6 */
201: srcsa.sa.sa_family = AF_INET;
202: break;
203: #ifdef INET6
204: case 6:
205: ip = NULL;
206: ip6 = mtod(m, struct ip6_hdr *);
207: srcsa.sa.sa_family = AF_INET6;
208: break;
209: #endif /* INET6 */
210: default:
211: goto bad;
212: }
213:
214: IP6_EXTHDR_GET(uh, struct udphdr *, m, iphlen, sizeof(struct udphdr));
215: if (!uh) {
216: udpstat.udps_hdrops++;
217: return;
218: }
219:
220: /* Check for illegal destination port 0 */
221: if (uh->uh_dport == 0) {
222: udpstat.udps_noport++;
223: goto bad;
224: }
225:
226: /*
227: * Make mbuf data length reflect UDP length.
228: * If not enough data to reflect UDP length, drop.
229: */
230: len = ntohs((u_int16_t)uh->uh_ulen);
231: if (ip) {
232: if (m->m_pkthdr.len - iphlen != len) {
233: if (len > (m->m_pkthdr.len - iphlen) ||
234: len < sizeof(struct udphdr)) {
235: udpstat.udps_badlen++;
236: goto bad;
237: }
238: m_adj(m, len - (m->m_pkthdr.len - iphlen));
239: }
240: }
241: #ifdef INET6
242: else if (ip6) {
243: /* jumbograms */
244: if (len == 0 && m->m_pkthdr.len - iphlen > 0xffff)
245: len = m->m_pkthdr.len - iphlen;
246: if (len != m->m_pkthdr.len - iphlen) {
247: udpstat.udps_badlen++;
248: goto bad;
249: }
250: }
251: #endif
252: else /* shouldn't happen */
253: goto bad;
254:
255: /*
256: * Save a copy of the IP header in case we want restore it
257: * for sending an ICMP error message in response.
258: */
259: if (ip)
260: save_ip = *ip;
261:
262: /*
263: * Checksum extended UDP header and data.
264: * from W.R.Stevens: check incoming udp cksums even if
265: * udpcksum is not set.
266: */
267: savesum = uh->uh_sum;
268: #ifdef INET6
269: if (ip6) {
270: /* Be proactive about malicious use of IPv4 mapped address */
271: if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||
272: IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {
273: /* XXX stat */
274: goto bad;
275: }
276:
277: /*
278: * In IPv6, the UDP checksum is ALWAYS used.
279: */
280: if (uh->uh_sum == 0) {
281: udpstat.udps_nosum++;
282: goto bad;
283: }
284: if ((uh->uh_sum = in6_cksum(m, IPPROTO_UDP, iphlen, len))) {
285: udpstat.udps_badsum++;
286: goto bad;
287: }
288: } else
289: #endif /* INET6 */
290: if (uh->uh_sum) {
291: if ((m->m_pkthdr.csum_flags & M_UDP_CSUM_IN_OK) == 0) {
292: if (m->m_pkthdr.csum_flags & M_UDP_CSUM_IN_BAD) {
293: udpstat.udps_badsum++;
294: udpstat.udps_inhwcsum++;
295: m_freem(m);
296: return;
297: }
298:
299: if ((uh->uh_sum = in4_cksum(m, IPPROTO_UDP,
300: iphlen, len))) {
301: udpstat.udps_badsum++;
302: m_freem(m);
303: return;
304: }
305: } else {
306: m->m_pkthdr.csum_flags &= ~M_UDP_CSUM_IN_OK;
307: udpstat.udps_inhwcsum++;
308: }
309: } else
310: udpstat.udps_nosum++;
311:
312: #ifdef IPSEC
313: if (udpencap_enable && udpencap_port &&
314: uh->uh_dport == htons(udpencap_port)) {
315: u_int32_t spi;
316: int skip = iphlen + sizeof(struct udphdr);
317:
318: if (m->m_pkthdr.len - skip < sizeof(u_int32_t)) {
319: /* packet too short */
320: m_freem(m);
321: return;
322: }
323: m_copydata(m, skip, sizeof(u_int32_t), (caddr_t) &spi);
324: /*
325: * decapsulate if the SPI is not zero, otherwise pass
326: * to userland
327: */
328: if (spi != 0) {
329: if ((m = m_pullup2(m, skip)) == NULL) {
330: udpstat.udps_hdrops++;
331: return;
332: }
333:
334: /* remove the UDP header */
335: bcopy(mtod(m, u_char *),
336: mtod(m, u_char *) + sizeof(struct udphdr), iphlen);
337: m_adj(m, sizeof(struct udphdr));
338: skip -= sizeof(struct udphdr);
339:
340: espstat.esps_udpencin++;
341: ipsec_common_input(m, skip, offsetof(struct ip, ip_p),
342: srcsa.sa.sa_family, IPPROTO_ESP, 1);
343: return;
344: }
345: }
346: #endif
347:
348: switch (srcsa.sa.sa_family) {
349: case AF_INET:
350: bzero(&srcsa, sizeof(struct sockaddr_in));
351: srcsa.sin.sin_len = sizeof(struct sockaddr_in);
352: srcsa.sin.sin_family = AF_INET;
353: srcsa.sin.sin_port = uh->uh_sport;
354: srcsa.sin.sin_addr = ip->ip_src;
355:
356: bzero(&dstsa, sizeof(struct sockaddr_in));
357: dstsa.sin.sin_len = sizeof(struct sockaddr_in);
358: dstsa.sin.sin_family = AF_INET;
359: dstsa.sin.sin_port = uh->uh_dport;
360: dstsa.sin.sin_addr = ip->ip_dst;
361: break;
362: #ifdef INET6
363: case AF_INET6:
364: bzero(&srcsa, sizeof(struct sockaddr_in6));
365: srcsa.sin6.sin6_len = sizeof(struct sockaddr_in6);
366: srcsa.sin6.sin6_family = AF_INET6;
367: srcsa.sin6.sin6_port = uh->uh_sport;
368: #if 0 /*XXX inbound flowinfo */
369: srcsa.sin6.sin6_flowinfo = htonl(0x0fffffff) & ip6->ip6_flow;
370: #endif
371: /* KAME hack: recover scopeid */
372: (void)in6_recoverscope(&srcsa.sin6, &ip6->ip6_src,
373: m->m_pkthdr.rcvif);
374:
375: bzero(&dstsa, sizeof(struct sockaddr_in6));
376: dstsa.sin6.sin6_len = sizeof(struct sockaddr_in6);
377: dstsa.sin6.sin6_family = AF_INET6;
378: dstsa.sin6.sin6_port = uh->uh_dport;
379: /* KAME hack: recover scopeid */
380: (void)in6_recoverscope(&dstsa.sin6, &ip6->ip6_dst,
381: m->m_pkthdr.rcvif);
382: break;
383: #endif /* INET6 */
384: }
385:
386: #ifdef INET6
387: if ((ip6 && IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) ||
388: (ip && IN_MULTICAST(ip->ip_dst.s_addr)) ||
389: (ip && in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif))) {
390: #else /* INET6 */
391: if (IN_MULTICAST(ip->ip_dst.s_addr) ||
392: in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) {
393: #endif /* INET6 */
394: struct inpcb *last;
395: /*
396: * Deliver a multicast or broadcast datagram to *all* sockets
397: * for which the local and remote addresses and ports match
398: * those of the incoming datagram. This allows more than
399: * one process to receive multi/broadcasts on the same port.
400: * (This really ought to be done for unicast datagrams as
401: * well, but that would cause problems with existing
402: * applications that open both address-specific sockets and
403: * a wildcard socket listening to the same port -- they would
404: * end up receiving duplicates of every unicast datagram.
405: * Those applications open the multiple sockets to overcome an
406: * inadequacy of the UDP socket interface, but for backwards
407: * compatibility we avoid the problem here rather than
408: * fixing the interface. Maybe 4.5BSD will remedy this?)
409: */
410:
411: iphlen += sizeof(struct udphdr);
412:
413: /*
414: * Locate pcb(s) for datagram.
415: * (Algorithm copied from raw_intr().)
416: */
417: last = NULL;
418: CIRCLEQ_FOREACH(inp, &udbtable.inpt_queue, inp_queue) {
419: #ifdef INET6
420: /* don't accept it if AF does not match */
421: if (ip6 && !(inp->inp_flags & INP_IPV6))
422: continue;
423: if (!ip6 && (inp->inp_flags & INP_IPV6))
424: continue;
425: #endif
426: if (inp->inp_lport != uh->uh_dport)
427: continue;
428: #ifdef INET6
429: if (ip6) {
430: if (!IN6_IS_ADDR_UNSPECIFIED(&inp->inp_laddr6))
431: if (!IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6,
432: &ip6->ip6_dst))
433: continue;
434: } else
435: #endif /* INET6 */
436: if (inp->inp_laddr.s_addr != INADDR_ANY) {
437: if (inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
438: continue;
439: }
440: #ifdef INET6
441: if (ip6) {
442: if (!IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6))
443: if (!IN6_ARE_ADDR_EQUAL(&inp->inp_faddr6,
444: &ip6->ip6_src) ||
445: inp->inp_fport != uh->uh_sport)
446: continue;
447: } else
448: #endif /* INET6 */
449: if (inp->inp_faddr.s_addr != INADDR_ANY) {
450: if (inp->inp_faddr.s_addr !=
451: ip->ip_src.s_addr ||
452: inp->inp_fport != uh->uh_sport)
453: continue;
454: }
455:
456: if (last != NULL) {
457: struct mbuf *n;
458:
459: if ((n = m_copy(m, 0, M_COPYALL)) != NULL) {
460: #ifdef INET6
461: if (ip6 && (last->inp_flags &
462: IN6P_CONTROLOPTS))
463: ip6_savecontrol(last, n, &opts);
464: #endif /* INET6 */
465: if (ip && (last->inp_flags &
466: INP_CONTROLOPTS))
467: ip_savecontrol(last, &opts,
468: ip, n);
469:
470: m_adj(n, iphlen);
471: if (sbappendaddr(
472: &last->inp_socket->so_rcv,
473: &srcsa.sa, n, opts) == 0) {
474: m_freem(n);
475: if (opts)
476: m_freem(opts);
477: udpstat.udps_fullsock++;
478: } else
479: sorwakeup(last->inp_socket);
480: opts = NULL;
481: }
482: }
483: last = inp;
484: /*
485: * Don't look for additional matches if this one does
486: * not have either the SO_REUSEPORT or SO_REUSEADDR
487: * socket options set. This heuristic avoids searching
488: * through all pcbs in the common case of a non-shared
489: * port. It * assumes that an application will never
490: * clear these options after setting them.
491: */
492: if ((last->inp_socket->so_options & (SO_REUSEPORT |
493: SO_REUSEADDR)) == 0)
494: break;
495: }
496:
497: if (last == NULL) {
498: /*
499: * No matching pcb found; discard datagram.
500: * (No need to send an ICMP Port Unreachable
501: * for a broadcast or multicast datgram.)
502: */
503: udpstat.udps_noportbcast++;
504: goto bad;
505: }
506:
507: #ifdef INET6
508: if (ip6 && (last->inp_flags & IN6P_CONTROLOPTS))
509: ip6_savecontrol(last, m, &opts);
510: #endif /* INET6 */
511: if (ip && (last->inp_flags & INP_CONTROLOPTS))
512: ip_savecontrol(last, &opts, ip, m);
513:
514: m_adj(m, iphlen);
515: if (sbappendaddr(&last->inp_socket->so_rcv,
516: &srcsa.sa, m, opts) == 0) {
517: udpstat.udps_fullsock++;
518: goto bad;
519: }
520: sorwakeup(last->inp_socket);
521: return;
522: }
523: /*
524: * Locate pcb for datagram.
525: */
526: #ifdef INET6
527: if (ip6)
528: inp = in6_pcbhashlookup(&udbtable, &ip6->ip6_src, uh->uh_sport,
529: &ip6->ip6_dst, uh->uh_dport);
530: else
531: #endif /* INET6 */
532: inp = in_pcbhashlookup(&udbtable, ip->ip_src, uh->uh_sport,
533: ip->ip_dst, uh->uh_dport);
534: if (inp == 0) {
535: int inpl_reverse = 0;
536: if (m->m_pkthdr.pf.flags & PF_TAG_TRANSLATE_LOCALHOST)
537: inpl_reverse = 1;
538: ++udpstat.udps_pcbhashmiss;
539: #ifdef INET6
540: if (ip6) {
541: inp = in6_pcblookup_listen(&udbtable,
542: &ip6->ip6_dst, uh->uh_dport, inpl_reverse);
543: } else
544: #endif /* INET6 */
545: inp = in_pcblookup_listen(&udbtable,
546: ip->ip_dst, uh->uh_dport, inpl_reverse);
547: if (inp == 0) {
548: udpstat.udps_noport++;
549: if (m->m_flags & (M_BCAST | M_MCAST)) {
550: udpstat.udps_noportbcast++;
551: goto bad;
552: }
553: #ifdef INET6
554: if (ip6) {
555: uh->uh_sum = savesum;
556: icmp6_error(m, ICMP6_DST_UNREACH,
557: ICMP6_DST_UNREACH_NOPORT,0);
558: } else
559: #endif /* INET6 */
560: {
561: *ip = save_ip;
562: uh->uh_sum = savesum;
563: icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT,
564: 0, 0);
565: }
566: return;
567: }
568: }
569:
570: #ifdef IPSEC
571: mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL);
572: s = splnet();
573: if (mtag != NULL) {
574: tdbi = (struct tdb_ident *)(mtag + 1);
575: tdb = gettdb(tdbi->spi, &tdbi->dst, tdbi->proto);
576: } else
577: tdb = NULL;
578: ipsp_spd_lookup(m, srcsa.sa.sa_family, iphlen, &error,
579: IPSP_DIRECTION_IN, tdb, inp);
580: if (error) {
581: splx(s);
582: goto bad;
583: }
584:
585: /* Latch SA only if the socket is connected */
586: if (inp->inp_tdb_in != tdb &&
587: (inp->inp_socket->so_state & SS_ISCONNECTED)) {
588: if (tdb) {
589: tdb_add_inp(tdb, inp, 1);
590: if (inp->inp_ipo == NULL) {
591: inp->inp_ipo = ipsec_add_policy(inp,
592: srcsa.sa.sa_family, IPSP_DIRECTION_OUT);
593: if (inp->inp_ipo == NULL) {
594: splx(s);
595: goto bad;
596: }
597: }
598: if (inp->inp_ipo->ipo_dstid == NULL &&
599: tdb->tdb_srcid != NULL) {
600: inp->inp_ipo->ipo_dstid = tdb->tdb_srcid;
601: tdb->tdb_srcid->ref_count++;
602: }
603: if (inp->inp_ipsec_remotecred == NULL &&
604: tdb->tdb_remote_cred != NULL) {
605: inp->inp_ipsec_remotecred =
606: tdb->tdb_remote_cred;
607: tdb->tdb_remote_cred->ref_count++;
608: }
609: if (inp->inp_ipsec_remoteauth == NULL &&
610: tdb->tdb_remote_auth != NULL) {
611: inp->inp_ipsec_remoteauth =
612: tdb->tdb_remote_auth;
613: tdb->tdb_remote_auth->ref_count++;
614: }
615: } else { /* Just reset */
616: TAILQ_REMOVE(&inp->inp_tdb_in->tdb_inp_in, inp,
617: inp_tdb_in_next);
618: inp->inp_tdb_in = NULL;
619: }
620: }
621: splx(s);
622: #endif /*IPSEC */
623:
624: opts = NULL;
625: #ifdef INET6
626: if (ip6 && (inp->inp_flags & IN6P_CONTROLOPTS))
627: ip6_savecontrol(inp, m, &opts);
628: #endif /* INET6 */
629: if (ip && (inp->inp_flags & INP_CONTROLOPTS))
630: ip_savecontrol(inp, &opts, ip, m);
631:
632: iphlen += sizeof(struct udphdr);
633: m_adj(m, iphlen);
634: if (sbappendaddr(&inp->inp_socket->so_rcv, &srcsa.sa, m, opts) == 0) {
635: udpstat.udps_fullsock++;
636: goto bad;
637: }
638: sorwakeup(inp->inp_socket);
639: return;
640: bad:
641: m_freem(m);
642: if (opts)
643: m_freem(opts);
644: }
645:
646: /*
647: * Notify a udp user of an asynchronous error;
648: * just wake up so that he can collect error status.
649: */
650: void
651: udp_notify(inp, errno)
652: struct inpcb *inp;
653: int errno;
654: {
655: inp->inp_socket->so_error = errno;
656: sorwakeup(inp->inp_socket);
657: sowwakeup(inp->inp_socket);
658: }
659:
660: #ifdef INET6
661: void
662: udp6_ctlinput(cmd, sa, d)
663: int cmd;
664: struct sockaddr *sa;
665: void *d;
666: {
667: struct udphdr uh;
668: struct sockaddr_in6 sa6;
669: struct ip6_hdr *ip6;
670: struct mbuf *m;
671: int off;
672: void *cmdarg;
673: struct ip6ctlparam *ip6cp = NULL;
674: struct udp_portonly {
675: u_int16_t uh_sport;
676: u_int16_t uh_dport;
677: } *uhp;
678: void (*notify)(struct inpcb *, int) = udp_notify;
679:
680: if (sa == NULL)
681: return;
682: if (sa->sa_family != AF_INET6 ||
683: sa->sa_len != sizeof(struct sockaddr_in6))
684: return;
685:
686: if ((unsigned)cmd >= PRC_NCMDS)
687: return;
688: if (PRC_IS_REDIRECT(cmd))
689: notify = in_rtchange, d = NULL;
690: else if (cmd == PRC_HOSTDEAD)
691: d = NULL;
692: else if (cmd == PRC_MSGSIZE)
693: ; /* special code is present, see below */
694: else if (inet6ctlerrmap[cmd] == 0)
695: return;
696:
697: /* if the parameter is from icmp6, decode it. */
698: if (d != NULL) {
699: ip6cp = (struct ip6ctlparam *)d;
700: m = ip6cp->ip6c_m;
701: ip6 = ip6cp->ip6c_ip6;
702: off = ip6cp->ip6c_off;
703: cmdarg = ip6cp->ip6c_cmdarg;
704: } else {
705: m = NULL;
706: ip6 = NULL;
707: cmdarg = NULL;
708: /* XXX: translate addresses into internal form */
709: sa6 = *(struct sockaddr_in6 *)sa;
710: #ifndef SCOPEDROUTING
711: if (in6_embedscope(&sa6.sin6_addr, &sa6, NULL, NULL)) {
712: /* should be impossible */
713: return;
714: }
715: #endif
716: }
717:
718: if (ip6cp && ip6cp->ip6c_finaldst) {
719: bzero(&sa6, sizeof(sa6));
720: sa6.sin6_family = AF_INET6;
721: sa6.sin6_len = sizeof(sa6);
722: sa6.sin6_addr = *ip6cp->ip6c_finaldst;
723: /* XXX: assuming M is valid in this case */
724: sa6.sin6_scope_id = in6_addr2scopeid(m->m_pkthdr.rcvif,
725: ip6cp->ip6c_finaldst);
726: #ifndef SCOPEDROUTING
727: if (in6_embedscope(ip6cp->ip6c_finaldst, &sa6, NULL, NULL)) {
728: /* should be impossible */
729: return;
730: }
731: #endif
732: } else {
733: /* XXX: translate addresses into internal form */
734: sa6 = *(struct sockaddr_in6 *)sa;
735: #ifndef SCOPEDROUTING
736: if (in6_embedscope(&sa6.sin6_addr, &sa6, NULL, NULL)) {
737: /* should be impossible */
738: return;
739: }
740: #endif
741: }
742:
743: if (ip6) {
744: /*
745: * XXX: We assume that when IPV6 is non NULL,
746: * M and OFF are valid.
747: */
748: struct sockaddr_in6 sa6_src;
749:
750: /* check if we can safely examine src and dst ports */
751: if (m->m_pkthdr.len < off + sizeof(*uhp))
752: return;
753:
754: bzero(&uh, sizeof(uh));
755: m_copydata(m, off, sizeof(*uhp), (caddr_t)&uh);
756:
757: bzero(&sa6_src, sizeof(sa6_src));
758: sa6_src.sin6_family = AF_INET6;
759: sa6_src.sin6_len = sizeof(sa6_src);
760: sa6_src.sin6_addr = ip6->ip6_src;
761: sa6_src.sin6_scope_id = in6_addr2scopeid(m->m_pkthdr.rcvif,
762: &ip6->ip6_src);
763: #ifndef SCOPEDROUTING
764: if (in6_embedscope(&sa6_src.sin6_addr, &sa6_src, NULL, NULL)) {
765: /* should be impossible */
766: return;
767: }
768: #endif
769:
770: if (cmd == PRC_MSGSIZE) {
771: int valid = 0;
772:
773: /*
774: * Check to see if we have a valid UDP socket
775: * corresponding to the address in the ICMPv6 message
776: * payload.
777: */
778: if (in6_pcbhashlookup(&udbtable, &sa6.sin6_addr,
779: uh.uh_dport, &sa6_src.sin6_addr, uh.uh_sport))
780: valid = 1;
781: #if 0
782: /*
783: * As the use of sendto(2) is fairly popular,
784: * we may want to allow non-connected pcb too.
785: * But it could be too weak against attacks...
786: * We should at least check if the local address (= s)
787: * is really ours.
788: */
789: else if (in6_pcblookup_listen(&udbtable,
790: &sa6_src.sin6_addr, uh.uh_sport, 0);
791: valid = 1;
792: #endif
793:
794: /*
795: * Depending on the value of "valid" and routing table
796: * size (mtudisc_{hi,lo}wat), we will:
797: * - recalculate the new MTU and create the
798: * corresponding routing entry, or
799: * - ignore the MTU change notification.
800: */
801: icmp6_mtudisc_update((struct ip6ctlparam *)d, valid);
802:
803: /*
804: * regardless of if we called icmp6_mtudisc_update(),
805: * we need to call in6_pcbnotify(), to notify path
806: * MTU change to the userland (2292bis-02), because
807: * some unconnected sockets may share the same
808: * destination and want to know the path MTU.
809: */
810: }
811:
812: (void) in6_pcbnotify(&udbtable, (struct sockaddr *)&sa6,
813: uh.uh_dport, (struct sockaddr *)&sa6_src,
814: uh.uh_sport, cmd, cmdarg, notify);
815: } else {
816: (void) in6_pcbnotify(&udbtable, (struct sockaddr *)&sa6, 0,
817: (struct sockaddr *)&sa6_any, 0, cmd, cmdarg, notify);
818: }
819: }
820: #endif
821:
822: void *
823: udp_ctlinput(cmd, sa, v)
824: int cmd;
825: struct sockaddr *sa;
826: void *v;
827: {
828: struct ip *ip = v;
829: struct udphdr *uhp;
830: struct in_addr faddr;
831: struct inpcb *inp;
832: extern int inetctlerrmap[];
833: void (*notify)(struct inpcb *, int) = udp_notify;
834: int errno;
835:
836: if (sa == NULL)
837: return NULL;
838: if (sa->sa_family != AF_INET ||
839: sa->sa_len != sizeof(struct sockaddr_in))
840: return NULL;
841: faddr = satosin(sa)->sin_addr;
842: if (faddr.s_addr == INADDR_ANY)
843: return NULL;
844:
845: if ((unsigned)cmd >= PRC_NCMDS)
846: return NULL;
847: errno = inetctlerrmap[cmd];
848: if (PRC_IS_REDIRECT(cmd))
849: notify = in_rtchange, ip = 0;
850: else if (cmd == PRC_HOSTDEAD)
851: ip = 0;
852: else if (errno == 0)
853: return NULL;
854: if (ip) {
855: uhp = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
856:
857: #ifdef IPSEC
858: /* PMTU discovery for udpencap */
859: if (cmd == PRC_MSGSIZE && ip_mtudisc && udpencap_enable &&
860: udpencap_port && uhp->uh_sport == htons(udpencap_port)) {
861: udpencap_ctlinput(cmd, sa, v);
862: return (NULL);
863: }
864: #endif
865: inp = in_pcbhashlookup(&udbtable,
866: ip->ip_dst, uhp->uh_dport, ip->ip_src, uhp->uh_sport);
867: if (inp && inp->inp_socket != NULL)
868: notify(inp, errno);
869: } else
870: in_pcbnotifyall(&udbtable, sa, errno, notify);
871: return (NULL);
872: }
873:
874: int
875: udp_output(struct mbuf *m, ...)
876: {
877: struct inpcb *inp;
878: struct mbuf *addr, *control;
879: struct udpiphdr *ui;
880: int len = m->m_pkthdr.len;
881: struct in_addr laddr;
882: int s = 0, error = 0;
883: va_list ap;
884:
885: va_start(ap, m);
886: inp = va_arg(ap, struct inpcb *);
887: addr = va_arg(ap, struct mbuf *);
888: control = va_arg(ap, struct mbuf *);
889: va_end(ap);
890:
891: #ifdef DIAGNOSTIC
892: if ((inp->inp_flags & INP_IPV6) != 0)
893: panic("IPv6 inpcb to udp_output");
894: #endif
895:
896: /*
897: * Compute the packet length of the IP header, and
898: * punt if the length looks bogus.
899: */
900: if ((len + sizeof(struct udpiphdr)) > IP_MAXPACKET) {
901: error = EMSGSIZE;
902: goto release;
903: }
904:
905: if (addr) {
906: laddr = inp->inp_laddr;
907: if (inp->inp_faddr.s_addr != INADDR_ANY) {
908: error = EISCONN;
909: goto release;
910: }
911: /*
912: * Must block input while temporarily connected.
913: */
914: s = splsoftnet();
915: error = in_pcbconnect(inp, addr);
916: if (error) {
917: splx(s);
918: goto release;
919: }
920: } else {
921: if (inp->inp_faddr.s_addr == INADDR_ANY) {
922: error = ENOTCONN;
923: goto release;
924: }
925: }
926: /*
927: * Calculate data length and get a mbuf
928: * for UDP and IP headers.
929: */
930: M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT);
931: if (m == 0) {
932: error = ENOBUFS;
933: goto bail;
934: }
935:
936: /*
937: * Fill in mbuf with extended UDP header
938: * and addresses and length put into network format.
939: */
940: ui = mtod(m, struct udpiphdr *);
941: bzero(ui->ui_x1, sizeof ui->ui_x1);
942: ui->ui_pr = IPPROTO_UDP;
943: ui->ui_len = htons((u_int16_t)len + sizeof (struct udphdr));
944: ui->ui_src = inp->inp_laddr;
945: ui->ui_dst = inp->inp_faddr;
946: ui->ui_sport = inp->inp_lport;
947: ui->ui_dport = inp->inp_fport;
948: ui->ui_ulen = ui->ui_len;
949:
950: /*
951: * Compute the pseudo-header checksum; defer further checksumming
952: * until ip_output() or hardware (if it exists).
953: */
954: if (udpcksum) {
955: m->m_pkthdr.csum_flags |= M_UDPV4_CSUM_OUT;
956: ui->ui_sum = in_cksum_phdr(ui->ui_src.s_addr,
957: ui->ui_dst.s_addr, htons((u_int16_t)len +
958: sizeof (struct udphdr) + IPPROTO_UDP));
959: } else
960: ui->ui_sum = 0;
961: ((struct ip *)ui)->ip_len = htons(sizeof (struct udpiphdr) + len);
962: ((struct ip *)ui)->ip_ttl = inp->inp_ip.ip_ttl;
963: ((struct ip *)ui)->ip_tos = inp->inp_ip.ip_tos;
964:
965: udpstat.udps_opackets++;
966: error = ip_output(m, inp->inp_options, &inp->inp_route,
967: inp->inp_socket->so_options &
968: (SO_DONTROUTE | SO_BROADCAST | SO_JUMBO),
969: inp->inp_moptions, inp);
970:
971: bail:
972: if (addr) {
973: inp->inp_laddr = laddr;
974: in_pcbdisconnect(inp);
975: splx(s);
976: }
977: if (control)
978: m_freem(control);
979: return (error);
980:
981: release:
982: m_freem(m);
983: if (control)
984: m_freem(control);
985: return (error);
986: }
987:
988: #ifdef INET6
989: /*ARGSUSED*/
990: int
991: udp6_usrreq(so, req, m, addr, control, p)
992: struct socket *so;
993: int req;
994: struct mbuf *m, *addr, *control;
995: struct proc *p;
996: {
997:
998: return udp_usrreq(so, req, m, addr, control);
999: }
1000: #endif
1001:
1002: /*ARGSUSED*/
1003: int
1004: udp_usrreq(so, req, m, addr, control)
1005: struct socket *so;
1006: int req;
1007: struct mbuf *m, *addr, *control;
1008: {
1009: struct inpcb *inp = sotoinpcb(so);
1010: int error = 0;
1011: int s;
1012:
1013: if (req == PRU_CONTROL) {
1014: #ifdef INET6
1015: if (inp->inp_flags & INP_IPV6)
1016: return (in6_control(so, (u_long)m, (caddr_t)addr,
1017: (struct ifnet *)control, 0));
1018: else
1019: #endif /* INET6 */
1020: return (in_control(so, (u_long)m, (caddr_t)addr,
1021: (struct ifnet *)control));
1022: }
1023: if (inp == NULL && req != PRU_ATTACH) {
1024: error = EINVAL;
1025: goto release;
1026: }
1027: /*
1028: * Note: need to block udp_input while changing
1029: * the udp pcb queue and/or pcb addresses.
1030: */
1031: switch (req) {
1032:
1033: case PRU_ATTACH:
1034: if (inp != NULL) {
1035: error = EINVAL;
1036: break;
1037: }
1038: s = splsoftnet();
1039: error = in_pcballoc(so, &udbtable);
1040: splx(s);
1041: if (error)
1042: break;
1043: error = soreserve(so, udp_sendspace, udp_recvspace);
1044: if (error)
1045: break;
1046: #ifdef INET6
1047: if (((struct inpcb *)so->so_pcb)->inp_flags & INP_IPV6)
1048: ((struct inpcb *) so->so_pcb)->inp_ipv6.ip6_hlim =
1049: ip6_defhlim;
1050: else
1051: #endif /* INET6 */
1052: ((struct inpcb *) so->so_pcb)->inp_ip.ip_ttl = ip_defttl;
1053: break;
1054:
1055: case PRU_DETACH:
1056: udp_detach(inp);
1057: break;
1058:
1059: case PRU_BIND:
1060: s = splsoftnet();
1061: #ifdef INET6
1062: if (inp->inp_flags & INP_IPV6)
1063: error = in6_pcbbind(inp, addr);
1064: else
1065: #endif
1066: error = in_pcbbind(inp, addr);
1067: splx(s);
1068: break;
1069:
1070: case PRU_LISTEN:
1071: error = EOPNOTSUPP;
1072: break;
1073:
1074: case PRU_CONNECT:
1075: #ifdef INET6
1076: if (inp->inp_flags & INP_IPV6) {
1077: if (!IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6)) {
1078: error = EISCONN;
1079: break;
1080: }
1081: s = splsoftnet();
1082: error = in6_pcbconnect(inp, addr);
1083: splx(s);
1084: } else
1085: #endif /* INET6 */
1086: {
1087: if (inp->inp_faddr.s_addr != INADDR_ANY) {
1088: error = EISCONN;
1089: break;
1090: }
1091: s = splsoftnet();
1092: error = in_pcbconnect(inp, addr);
1093: splx(s);
1094: }
1095:
1096: if (error == 0)
1097: soisconnected(so);
1098: break;
1099:
1100: case PRU_CONNECT2:
1101: error = EOPNOTSUPP;
1102: break;
1103:
1104: case PRU_ACCEPT:
1105: error = EOPNOTSUPP;
1106: break;
1107:
1108: case PRU_DISCONNECT:
1109: #ifdef INET6
1110: if (inp->inp_flags & INP_IPV6) {
1111: if (IN6_IS_ADDR_UNSPECIFIED(&inp->inp_faddr6)) {
1112: error = ENOTCONN;
1113: break;
1114: }
1115: } else
1116: #endif /* INET6 */
1117: {
1118: if (inp->inp_faddr.s_addr == INADDR_ANY) {
1119: error = ENOTCONN;
1120: break;
1121: }
1122: }
1123:
1124: s = splsoftnet();
1125: #ifdef INET6
1126: if (inp->inp_flags & INP_IPV6)
1127: inp->inp_laddr6 = in6addr_any;
1128: else
1129: #endif /* INET6 */
1130: inp->inp_laddr.s_addr = INADDR_ANY;
1131: in_pcbdisconnect(inp);
1132:
1133: splx(s);
1134: so->so_state &= ~SS_ISCONNECTED; /* XXX */
1135: break;
1136:
1137: case PRU_SHUTDOWN:
1138: socantsendmore(so);
1139: break;
1140:
1141: case PRU_SEND:
1142: #ifdef INET6
1143: if (inp->inp_flags & INP_IPV6)
1144: return (udp6_output(inp, m, addr, control));
1145: else
1146: return (udp_output(m, inp, addr, control));
1147: #else
1148: return (udp_output(m, inp, addr, control));
1149: #endif
1150:
1151: case PRU_ABORT:
1152: soisdisconnected(so);
1153: udp_detach(inp);
1154: break;
1155:
1156: case PRU_SOCKADDR:
1157: #ifdef INET6
1158: if (inp->inp_flags & INP_IPV6)
1159: in6_setsockaddr(inp, addr);
1160: else
1161: #endif /* INET6 */
1162: in_setsockaddr(inp, addr);
1163: break;
1164:
1165: case PRU_PEERADDR:
1166: #ifdef INET6
1167: if (inp->inp_flags & INP_IPV6)
1168: in6_setpeeraddr(inp, addr);
1169: else
1170: #endif /* INET6 */
1171: in_setpeeraddr(inp, addr);
1172: break;
1173:
1174: case PRU_SENSE:
1175: /*
1176: * stat: don't bother with a blocksize.
1177: */
1178: /*
1179: * Perhaps Path MTU might be returned for a connected
1180: * UDP socket in this case.
1181: */
1182: return (0);
1183:
1184: case PRU_SENDOOB:
1185: case PRU_FASTTIMO:
1186: case PRU_SLOWTIMO:
1187: case PRU_PROTORCV:
1188: case PRU_PROTOSEND:
1189: error = EOPNOTSUPP;
1190: break;
1191:
1192: case PRU_RCVD:
1193: case PRU_RCVOOB:
1194: return (EOPNOTSUPP); /* do not free mbuf's */
1195:
1196: default:
1197: panic("udp_usrreq");
1198: }
1199:
1200: release:
1201: if (control) {
1202: m_freem(control);
1203: }
1204: if (m)
1205: m_freem(m);
1206: return (error);
1207: }
1208:
1209: void
1210: udp_detach(inp)
1211: struct inpcb *inp;
1212: {
1213: int s = splsoftnet();
1214:
1215: in_pcbdetach(inp);
1216: splx(s);
1217: }
1218:
1219: /*
1220: * Sysctl for udp variables.
1221: */
1222: int
1223: udp_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
1224: int *name;
1225: u_int namelen;
1226: void *oldp;
1227: size_t *oldlenp;
1228: void *newp;
1229: size_t newlen;
1230: {
1231: /* All sysctl names at this level are terminal. */
1232: if (namelen != 1)
1233: return (ENOTDIR);
1234:
1235: switch (name[0]) {
1236: case UDPCTL_BADDYNAMIC:
1237: return (sysctl_struct(oldp, oldlenp, newp, newlen,
1238: baddynamicports.udp, sizeof(baddynamicports.udp)));
1239: default:
1240: if (name[0] < UDPCTL_MAXID)
1241: return (sysctl_int_arr(udpctl_vars, name, namelen,
1242: oldp, oldlenp, newp, newlen));
1243: return (ENOPROTOOPT);
1244: }
1245: /* NOTREACHED */
1246: }