1 /* $NetBSD: ip_output.c,v 1.200.4.1 2009/07/09 19:38:27 snj 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) 1998 The NetBSD Foundation, Inc.
34 * All rights reserved.
35 *
36 * This code is derived from software contributed to The NetBSD Foundation
37 * by Public Access Networks Corporation ("Panix"). It was developed under
38 * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 * 1. Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in the
47 * documentation and/or other materials provided with the distribution.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
50 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
51 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
52 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
53 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
54 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
55 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
56 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
57 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
58 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
59 * POSSIBILITY OF SUCH DAMAGE.
60 */
61
62 /*
63 * Copyright (c) 1982, 1986, 1988, 1990, 1993
64 * The Regents of the University of California. All rights reserved.
65 *
66 * Redistribution and use in source and binary forms, with or without
67 * modification, are permitted provided that the following conditions
68 * are met:
69 * 1. Redistributions of source code must retain the above copyright
70 * notice, this list of conditions and the following disclaimer.
71 * 2. Redistributions in binary form must reproduce the above copyright
72 * notice, this list of conditions and the following disclaimer in the
73 * documentation and/or other materials provided with the distribution.
74 * 3. Neither the name of the University nor the names of its contributors
75 * may be used to endorse or promote products derived from this software
76 * without specific prior written permission.
77 *
78 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
79 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
81 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
82 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
83 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
84 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
85 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
86 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
87 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
88 * SUCH DAMAGE.
89 *
90 * @(#)ip_output.c 8.3 (Berkeley) 1/21/94
91 */
92
93 #include <sys/cdefs.h>
94 __KERNEL_RCSID(0, "$NetBSD: ip_output.c,v 1.200.4.1 2009/07/09 19:38:27 snj Exp $");
95
96 #include "opt_pfil_hooks.h"
97 #include "opt_inet.h"
98 #include "opt_ipsec.h"
99 #include "opt_mrouting.h"
100
101 #include <sys/param.h>
102 #include <sys/malloc.h>
103 #include <sys/mbuf.h>
104 #include <sys/errno.h>
105 #include <sys/protosw.h>
106 #include <sys/socket.h>
107 #include <sys/socketvar.h>
108 #include <sys/kauth.h>
109 #ifdef FAST_IPSEC
110 #include <sys/domain.h>
111 #endif
112 #include <sys/systm.h>
113 #include <sys/proc.h>
114
115 #include <net/if.h>
116 #include <net/route.h>
117 #include <net/pfil.h>
118
119 #include <netinet/in.h>
120 #include <netinet/in_systm.h>
121 #include <netinet/ip.h>
122 #include <netinet/in_pcb.h>
123 #include <netinet/in_var.h>
124 #include <netinet/ip_var.h>
125 #include <netinet/ip_private.h>
126 #include <netinet/in_offload.h>
127
128 #ifdef MROUTING
129 #include <netinet/ip_mroute.h>
130 #endif
131
132 #include <machine/stdarg.h>
133
134 #ifdef IPSEC
135 #include <netinet6/ipsec.h>
136 #include <netinet6/ipsec_private.h>
137 #include <netkey/key.h>
138 #include <netkey/key_debug.h>
139 #endif /*IPSEC*/
140
141 #ifdef FAST_IPSEC
142 #include <netipsec/ipsec.h>
143 #include <netipsec/key.h>
144 #include <netipsec/xform.h>
145 #endif /* FAST_IPSEC*/
146
147 #ifdef IPSEC_NAT_T
148 #include <netinet/udp.h>
149 #endif
150
151 static struct mbuf *ip_insertoptions(struct mbuf *, struct mbuf *, int *);
152 static struct ifnet *ip_multicast_if(struct in_addr *, int *);
153 static void ip_mloopback(struct ifnet *, struct mbuf *,
154 const struct sockaddr_in *);
155
156 #ifdef PFIL_HOOKS
157 extern struct pfil_head inet_pfil_hook; /* XXX */
158 #endif
159
160 int ip_do_loopback_cksum = 0;
161
162 /*
163 * IP output. The packet in mbuf chain m contains a skeletal IP
164 * header (with len, off, ttl, proto, tos, src, dst).
165 * The mbuf chain containing the packet will be freed.
166 * The mbuf opt, if present, will not be freed.
167 */
168 int
169 ip_output(struct mbuf *m0, ...)
170 {
171 struct rtentry *rt;
172 struct ip *ip;
173 struct ifnet *ifp;
174 struct mbuf *m = m0;
175 int hlen = sizeof (struct ip);
176 int len, error = 0;
177 struct route iproute;
178 const struct sockaddr_in *dst;
179 struct in_ifaddr *ia;
180 struct ifaddr *xifa;
181 struct mbuf *opt;
182 struct route *ro;
183 int flags, sw_csum;
184 int *mtu_p;
185 u_long mtu;
186 struct ip_moptions *imo;
187 struct socket *so;
188 va_list ap;
189 #ifdef IPSEC_NAT_T
190 int natt_frag = 0;
191 #endif
192 #ifdef IPSEC
193 struct secpolicy *sp = NULL;
194 #endif /*IPSEC*/
195 #ifdef FAST_IPSEC
196 struct inpcb *inp;
197 struct secpolicy *sp = NULL;
198 int s;
199 #endif
200 u_int16_t ip_len;
201 union {
202 struct sockaddr dst;
203 struct sockaddr_in dst4;
204 } u;
205 struct sockaddr *rdst = &u.dst; /* real IP destination, as opposed
206 * to the nexthop
207 */
208
209 len = 0;
210 va_start(ap, m0);
211 opt = va_arg(ap, struct mbuf *);
212 ro = va_arg(ap, struct route *);
213 flags = va_arg(ap, int);
214 imo = va_arg(ap, struct ip_moptions *);
215 so = va_arg(ap, struct socket *);
216 if (flags & IP_RETURNMTU)
217 mtu_p = va_arg(ap, int *);
218 else
219 mtu_p = NULL;
220 va_end(ap);
221
222 MCLAIM(m, &ip_tx_mowner);
223 #ifdef FAST_IPSEC
224 if (so != NULL && so->so_proto->pr_domain->dom_family == AF_INET)
225 inp = (struct inpcb *)so->so_pcb;
226 else
227 inp = NULL;
228 #endif /* FAST_IPSEC */
229
230 #ifdef DIAGNOSTIC
231 if ((m->m_flags & M_PKTHDR) == 0)
232 panic("ip_output: no HDR");
233
234 if ((m->m_pkthdr.csum_flags & (M_CSUM_TCPv6|M_CSUM_UDPv6)) != 0) {
235 panic("ip_output: IPv6 checksum offload flags: %d",
236 m->m_pkthdr.csum_flags);
237 }
238
239 if ((m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) ==
240 (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
241 panic("ip_output: conflicting checksum offload flags: %d",
242 m->m_pkthdr.csum_flags);
243 }
244 #endif
245 if (opt) {
246 m = ip_insertoptions(m, opt, &len);
247 if (len >= sizeof(struct ip))
248 hlen = len;
249 }
250 ip = mtod(m, struct ip *);
251 /*
252 * Fill in IP header.
253 */
254 if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
255 ip->ip_v = IPVERSION;
256 ip->ip_off = htons(0);
257 /* ip->ip_id filled in after we find out source ia */
258 ip->ip_hl = hlen >> 2;
259 IP_STATINC(IP_STAT_LOCALOUT);
260 } else {
261 hlen = ip->ip_hl << 2;
262 }
263 /*
264 * Route packet.
265 */
266 memset(&iproute, 0, sizeof(iproute));
267 if (ro == NULL)
268 ro = &iproute;
269 sockaddr_in_init(&u.dst4, &ip->ip_dst, 0);
270 dst = satocsin(rtcache_getdst(ro));
271 /*
272 * If there is a cached route,
273 * check that it is to the same destination
274 * and is still up. If not, free it and try again.
275 * The address family should also be checked in case of sharing the
276 * cache with IPv6.
277 */
278 if (dst == NULL)
279 ;
280 else if (dst->sin_family != AF_INET ||
281 !in_hosteq(dst->sin_addr, ip->ip_dst))
282 rtcache_free(ro);
283
284 if ((rt = rtcache_validate(ro)) == NULL &&
285 (rt = rtcache_update(ro, 1)) == NULL) {
286 dst = &u.dst4;
287 rtcache_setdst(ro, &u.dst);
288 }
289 /*
290 * If routing to interface only,
291 * short circuit routing lookup.
292 */
293 if (flags & IP_ROUTETOIF) {
294 if ((ia = ifatoia(ifa_ifwithladdr(sintocsa(dst)))) == NULL) {
295 IP_STATINC(IP_STAT_NOROUTE);
296 error = ENETUNREACH;
297 goto bad;
298 }
299 ifp = ia->ia_ifp;
300 mtu = ifp->if_mtu;
301 ip->ip_ttl = 1;
302 } else if ((IN_MULTICAST(ip->ip_dst.s_addr) ||
303 ip->ip_dst.s_addr == INADDR_BROADCAST) &&
304 imo != NULL && imo->imo_multicast_ifp != NULL) {
305 ifp = imo->imo_multicast_ifp;
306 mtu = ifp->if_mtu;
307 IFP_TO_IA(ifp, ia);
308 } else {
309 if (rt == NULL)
310 rt = rtcache_init(ro);
311 if (rt == NULL) {
312 IP_STATINC(IP_STAT_NOROUTE);
313 error = EHOSTUNREACH;
314 goto bad;
315 }
316 ia = ifatoia(rt->rt_ifa);
317 ifp = rt->rt_ifp;
318 if ((mtu = rt->rt_rmx.rmx_mtu) == 0)
319 mtu = ifp->if_mtu;
320 rt->rt_use++;
321 if (rt->rt_flags & RTF_GATEWAY)
322 dst = satosin(rt->rt_gateway);
323 }
324 if (IN_MULTICAST(ip->ip_dst.s_addr) ||
325 (ip->ip_dst.s_addr == INADDR_BROADCAST)) {
326 struct in_multi *inm;
327
328 m->m_flags |= (ip->ip_dst.s_addr == INADDR_BROADCAST) ?
329 M_BCAST : M_MCAST;
330 /*
331 * See if the caller provided any multicast options
332 */
333 if (imo != NULL)
334 ip->ip_ttl = imo->imo_multicast_ttl;
335 else
336 ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
337
338 /*
339 * if we don't know the outgoing ifp yet, we can't generate
340 * output
341 */
342 if (!ifp) {
343 IP_STATINC(IP_STAT_NOROUTE);
344 error = ENETUNREACH;
345 goto bad;
346 }
347
348 /*
349 * If the packet is multicast or broadcast, confirm that
350 * the outgoing interface can transmit it.
351 */
352 if (((m->m_flags & M_MCAST) &&
353 (ifp->if_flags & IFF_MULTICAST) == 0) ||
354 ((m->m_flags & M_BCAST) &&
355 (ifp->if_flags & (IFF_BROADCAST|IFF_POINTOPOINT)) == 0)) {
356 IP_STATINC(IP_STAT_NOROUTE);
357 error = ENETUNREACH;
358 goto bad;
359 }
360 /*
361 * If source address not specified yet, use an address
362 * of outgoing interface.
363 */
364 if (in_nullhost(ip->ip_src)) {
365 struct in_ifaddr *xia;
366
367 IFP_TO_IA(ifp, xia);
368 if (!xia) {
369 error = EADDRNOTAVAIL;
370 goto bad;
371 }
372 xifa = &xia->ia_ifa;
373 if (xifa->ifa_getifa != NULL) {
374 xia = ifatoia((*xifa->ifa_getifa)(xifa, rdst));
375 }
376 ip->ip_src = xia->ia_addr.sin_addr;
377 }
378
379 IN_LOOKUP_MULTI(ip->ip_dst, ifp, inm);
380 if (inm != NULL &&
381 (imo == NULL || imo->imo_multicast_loop)) {
382 /*
383 * If we belong to the destination multicast group
384 * on the outgoing interface, and the caller did not
385 * forbid loopback, loop back a copy.
386 */
387 ip_mloopback(ifp, m, &u.dst4);
388 }
389 #ifdef MROUTING
390 else {
391 /*
392 * If we are acting as a multicast router, perform
393 * multicast forwarding as if the packet had just
394 * arrived on the interface to which we are about
395 * to send. The multicast forwarding function
396 * recursively calls this function, using the
397 * IP_FORWARDING flag to prevent infinite recursion.
398 *
399 * Multicasts that are looped back by ip_mloopback(),
400 * above, will be forwarded by the ip_input() routine,
401 * if necessary.
402 */
403 extern struct socket *ip_mrouter;
404
405 if (ip_mrouter && (flags & IP_FORWARDING) == 0) {
406 if (ip_mforward(m, ifp) != 0) {
407 m_freem(m);
408 goto done;
409 }
410 }
411 }
412 #endif
413 /*
414 * Multicasts with a time-to-live of zero may be looped-
415 * back, above, but must not be transmitted on a network.
416 * Also, multicasts addressed to the loopback interface
417 * are not sent -- the above call to ip_mloopback() will
418 * loop back a copy if this host actually belongs to the
419 * destination group on the loopback interface.
420 */
421 if (ip->ip_ttl == 0 || (ifp->if_flags & IFF_LOOPBACK) != 0) {
422 m_freem(m);
423 goto done;
424 }
425
426 goto sendit;
427 }
428 /*
429 * If source address not specified yet, use address
430 * of outgoing interface.
431 */
432 if (in_nullhost(ip->ip_src)) {
433 xifa = &ia->ia_ifa;
434 if (xifa->ifa_getifa != NULL)
435 ia = ifatoia((*xifa->ifa_getifa)(xifa, rdst));
436 ip->ip_src = ia->ia_addr.sin_addr;
437 }
438
439 /*
440 * packets with Class-D address as source are not valid per
441 * RFC 1112
442 */
443 if (IN_MULTICAST(ip->ip_src.s_addr)) {
444 IP_STATINC(IP_STAT_ODROPPED);
445 error = EADDRNOTAVAIL;
446 goto bad;
447 }
448
449 /*
450 * Look for broadcast address and
451 * and verify user is allowed to send
452 * such a packet.
453 */
454 if (in_broadcast(dst->sin_addr, ifp)) {
455 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
456 error = EADDRNOTAVAIL;
457 goto bad;
458 }
459 if ((flags & IP_ALLOWBROADCAST) == 0) {
460 error = EACCES;
461 goto bad;
462 }
463 /* don't allow broadcast messages to be fragmented */
464 if (ntohs(ip->ip_len) > ifp->if_mtu) {
465 error = EMSGSIZE;
466 goto bad;
467 }
468 m->m_flags |= M_BCAST;
469 } else
470 m->m_flags &= ~M_BCAST;
471
472 sendit:
473 if ((flags & (IP_FORWARDING|IP_NOIPNEWID)) == 0) {
474 if (m->m_pkthdr.len < IP_MINFRAGSIZE) {
475 ip->ip_id = 0;
476 } else if ((m->m_pkthdr.csum_flags & M_CSUM_TSOv4) == 0) {
477 ip->ip_id = ip_newid(ia);
478 } else {
479
480 /*
481 * TSO capable interfaces (typically?) increment
482 * ip_id for each segment.
483 * "allocate" enough ids here to increase the chance
484 * for them to be unique.
485 *
486 * note that the following calculation is not
487 * needed to be precise. wasting some ip_id is fine.
488 */
489
490 unsigned int segsz = m->m_pkthdr.segsz;
491 unsigned int datasz = ntohs(ip->ip_len) - hlen;
492 unsigned int num = howmany(datasz, segsz);
493
494 ip->ip_id = ip_newid_range(ia, num);
495 }
496 }
497 /*
498 * If we're doing Path MTU Discovery, we need to set DF unless
499 * the route's MTU is locked.
500 */
501 if ((flags & IP_MTUDISC) != 0 && rt != NULL &&
502 (rt->rt_rmx.rmx_locks & RTV_MTU) == 0)
503 ip->ip_off |= htons(IP_DF);
504
505 /* Remember the current ip_len */
506 ip_len = ntohs(ip->ip_len);
507
508 #ifdef IPSEC
509 /* get SP for this packet */
510 if (so == NULL)
511 sp = ipsec4_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND,
512 flags, &error);
513 else {
514 if (IPSEC_PCB_SKIP_IPSEC(sotoinpcb_hdr(so)->inph_sp,
515 IPSEC_DIR_OUTBOUND))
516 goto skip_ipsec;
517 sp = ipsec4_getpolicybysock(m, IPSEC_DIR_OUTBOUND, so, &error);
518 }
519
520 if (sp == NULL) {
521 IPSEC_STATINC(IPSEC_STAT_IN_INVAL);
522 goto bad;
523 }
524
525 error = 0;
526
527 /* check policy */
528 switch (sp->policy) {
529 case IPSEC_POLICY_DISCARD:
530 /*
531 * This packet is just discarded.
532 */
533 IPSEC_STATINC(IPSEC_STAT_OUT_POLVIO);
534 goto bad;
535
536 case IPSEC_POLICY_BYPASS:
537 case IPSEC_POLICY_NONE:
538 /* no need to do IPsec. */
539 goto skip_ipsec;
540
541 case IPSEC_POLICY_IPSEC:
542 if (sp->req == NULL) {
543 /* XXX should be panic ? */
544 printf("ip_output: No IPsec request specified.\n");
545 error = EINVAL;
546 goto bad;
547 }
548 break;
549
550 case IPSEC_POLICY_ENTRUST:
551 default:
552 printf("ip_output: Invalid policy found. %d\n", sp->policy);
553 }
554
555 #ifdef IPSEC_NAT_T
556 /*
557 * NAT-T ESP fragmentation: don't do IPSec processing now,
558 * we'll do it on each fragmented packet.
559 */
560 if (sp->req->sav &&
561 ((sp->req->sav->natt_type & UDP_ENCAP_ESPINUDP) ||
562 (sp->req->sav->natt_type & UDP_ENCAP_ESPINUDP_NON_IKE))) {
563 if (ntohs(ip->ip_len) > sp->req->sav->esp_frag) {
564 natt_frag = 1;
565 mtu = sp->req->sav->esp_frag;
566 goto skip_ipsec;
567 }
568 }
569 #endif /* IPSEC_NAT_T */
570
571 /*
572 * ipsec4_output() expects ip_len and ip_off in network
573 * order. They have been set to network order above.
574 */
575
576 {
577 struct ipsec_output_state state;
578 bzero(&state, sizeof(state));
579 state.m = m;
580 if (flags & IP_ROUTETOIF) {
581 state.ro = &iproute;
582 memset(&iproute, 0, sizeof(iproute));
583 } else
584 state.ro = ro;
585 state.dst = sintocsa(dst);
586
587 /*
588 * We can't defer the checksum of payload data if
589 * we're about to encrypt/authenticate it.
590 *
591 * XXX When we support crypto offloading functions of
592 * XXX network interfaces, we need to reconsider this,
593 * XXX since it's likely that they'll support checksumming,
594 * XXX as well.
595 */
596 if (m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
597 in_delayed_cksum(m);
598 m->m_pkthdr.csum_flags &= ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
599 }
600
601 error = ipsec4_output(&state, sp, flags);
602
603 m = state.m;
604 if (flags & IP_ROUTETOIF) {
605 /*
606 * if we have tunnel mode SA, we may need to ignore
607 * IP_ROUTETOIF.
608 */
609 if (state.ro != &iproute ||
610 rtcache_validate(state.ro) != NULL) {
611 flags &= ~IP_ROUTETOIF;
612 ro = state.ro;
613 }
614 } else
615 ro = state.ro;
616 dst = satocsin(state.dst);
617 if (error) {
618 /* mbuf is already reclaimed in ipsec4_output. */
619 m0 = NULL;
620 switch (error) {
621 case EHOSTUNREACH:
622 case ENETUNREACH:
623 case EMSGSIZE:
624 case ENOBUFS:
625 case ENOMEM:
626 break;
627 default:
628 printf("ip4_output (ipsec): error code %d\n", error);
629 /*fall through*/
630 case ENOENT:
631 /* don't show these error codes to the user */
632 error = 0;
633 break;
634 }
635 goto bad;
636 }
637
638 /* be sure to update variables that are affected by ipsec4_output() */
639 ip = mtod(m, struct ip *);
640 hlen = ip->ip_hl << 2;
641 ip_len = ntohs(ip->ip_len);
642
643 if ((rt = rtcache_validate(ro)) == NULL) {
644 if ((flags & IP_ROUTETOIF) == 0) {
645 printf("ip_output: "
646 "can't update route after IPsec processing\n");
647 error = EHOSTUNREACH; /*XXX*/
648 goto bad;
649 }
650 } else {
651 /* nobody uses ia beyond here */
652 if (state.encap) {
653 ifp = rt->rt_ifp;
654 if ((mtu = rt->rt_rmx.rmx_mtu) == 0)
655 mtu = ifp->if_mtu;
656 }
657 }
658 }
659 skip_ipsec:
660 #endif /*IPSEC*/
661 #ifdef FAST_IPSEC
662 /*
663 * Check the security policy (SP) for the packet and, if
664 * required, do IPsec-related processing. There are two
665 * cases here; the first time a packet is sent through
666 * it will be untagged and handled by ipsec4_checkpolicy.
667 * If the packet is resubmitted to ip_output (e.g. after
668 * AH, ESP, etc. processing), there will be a tag to bypass
669 * the lookup and related policy checking.
670 */
671 if (!ipsec_outdone(m)) {
672 s = splsoftnet();
673 if (inp != NULL &&
674 IPSEC_PCB_SKIP_IPSEC(inp->inp_sp, IPSEC_DIR_OUTBOUND)) {
675 splx(s);
676 goto spd_done;
677 }
678 sp = ipsec4_checkpolicy(m, IPSEC_DIR_OUTBOUND, flags,
679 &error, inp);
680 /*
681 * There are four return cases:
682 * sp != NULL apply IPsec policy
683 * sp == NULL, error == 0 no IPsec handling needed
684 * sp == NULL, error == -EINVAL discard packet w/o error
685 * sp == NULL, error != 0 discard packet, report error
686 */
687 if (sp != NULL) {
688 #ifdef IPSEC_NAT_T
689 /*
690 * NAT-T ESP fragmentation: don't do IPSec processing now,
691 * we'll do it on each fragmented packet.
692 */
693 if (sp->req->sav &&
694 ((sp->req->sav->natt_type & UDP_ENCAP_ESPINUDP) ||
695 (sp->req->sav->natt_type & UDP_ENCAP_ESPINUDP_NON_IKE))) {
696 if (ntohs(ip->ip_len) > sp->req->sav->esp_frag) {
697 natt_frag = 1;
698 mtu = sp->req->sav->esp_frag;
699 splx(s);
700 goto spd_done;
701 }
702 }
703 #endif /* IPSEC_NAT_T */
704
705 /*
706 * Do delayed checksums now because we send before
707 * this is done in the normal processing path.
708 */
709 if (m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
710 in_delayed_cksum(m);
711 m->m_pkthdr.csum_flags &= ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
712 }
713
714 #ifdef __FreeBSD__
715 ip->ip_len = htons(ip->ip_len);
716 ip->ip_off = htons(ip->ip_off);
717 #endif
718
719 /* NB: callee frees mbuf */
720 error = ipsec4_process_packet(m, sp->req, flags, 0);
721 /*
722 * Preserve KAME behaviour: ENOENT can be returned
723 * when an SA acquire is in progress. Don't propagate
724 * this to user-level; it confuses applications.
725 *
726 * XXX this will go away when the SADB is redone.
727 */
728 if (error == ENOENT)
729 error = 0;
730 splx(s);
731 goto done;
732 } else {
733 splx(s);
734
735 if (error != 0) {
736 /*
737 * Hack: -EINVAL is used to signal that a packet
738 * should be silently discarded. This is typically
739 * because we asked key management for an SA and
740 * it was delayed (e.g. kicked up to IKE).
741 */
742 if (error == -EINVAL)
743 error = 0;
744 goto bad;
745 } else {
746 /* No IPsec processing for this packet. */
747 }
748 }
749 }
750 spd_done:
751 #endif /* FAST_IPSEC */
752
753 #ifdef PFIL_HOOKS
754 /*
755 * Run through list of hooks for output packets.
756 */
757 if ((error = pfil_run_hooks(&inet_pfil_hook, &m, ifp, PFIL_OUT)) != 0)
758 goto done;
759 if (m == NULL)
760 goto done;
761
762 ip = mtod(m, struct ip *);
763 hlen = ip->ip_hl << 2;
764 ip_len = ntohs(ip->ip_len);
765 #endif /* PFIL_HOOKS */
766
767 m->m_pkthdr.csum_data |= hlen << 16;
768
769 #if IFA_STATS
770 /*
771 * search for the source address structure to
772 * maintain output statistics.
773 */
774 INADDR_TO_IA(ip->ip_src, ia);
775 #endif
776
777 /* Maybe skip checksums on loopback interfaces. */
778 if (IN_NEED_CHECKSUM(ifp, M_CSUM_IPv4)) {
779 m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
780 }
781 sw_csum = m->m_pkthdr.csum_flags & ~ifp->if_csum_flags_tx;
782 /*
783 * If small enough for mtu of path, or if using TCP segmentation
784 * offload, can just send directly.
785 */
786 if (ip_len <= mtu ||
787 (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) != 0) {
788 #if IFA_STATS
789 if (ia)
790 ia->ia_ifa.ifa_data.ifad_outbytes += ip_len;
791 #endif
792 /*
793 * Always initialize the sum to 0! Some HW assisted
794 * checksumming requires this.
795 */
796 ip->ip_sum = 0;
797
798 if ((m->m_pkthdr.csum_flags & M_CSUM_TSOv4) == 0) {
799 /*
800 * Perform any checksums that the hardware can't do
801 * for us.
802 *
803 * XXX Does any hardware require the {th,uh}_sum
804 * XXX fields to be 0?
805 */
806 if (sw_csum & M_CSUM_IPv4) {
807 KASSERT(IN_NEED_CHECKSUM(ifp, M_CSUM_IPv4));
808 ip->ip_sum = in_cksum(m, hlen);
809 m->m_pkthdr.csum_flags &= ~M_CSUM_IPv4;
810 }
811 if (sw_csum & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
812 if (IN_NEED_CHECKSUM(ifp,
813 sw_csum & (M_CSUM_TCPv4|M_CSUM_UDPv4))) {
814 in_delayed_cksum(m);
815 }
816 m->m_pkthdr.csum_flags &=
817 ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
818 }
819 }
820
821 #ifdef IPSEC
822 /* clean ipsec history once it goes out of the node */
823 ipsec_delaux(m);
824 #endif
825
826 if (__predict_true(
827 (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) == 0 ||
828 (ifp->if_capenable & IFCAP_TSOv4) != 0)) {
829 error =
830 (*ifp->if_output)(ifp, m,
831 (m->m_flags & M_MCAST) ?
832 sintocsa(rdst) : sintocsa(dst),
833 rt);
834 } else {
835 error =
836 ip_tso_output(ifp, m,
837 (m->m_flags & M_MCAST) ?
838 sintocsa(rdst) : sintocsa(dst),
839 rt);
840 }
841 goto done;
842 }
843
844 /*
845 * We can't use HW checksumming if we're about to
846 * to fragment the packet.
847 *
848 * XXX Some hardware can do this.
849 */
850 if (m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
851 if (IN_NEED_CHECKSUM(ifp,
852 m->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4))) {
853 in_delayed_cksum(m);
854 }
855 m->m_pkthdr.csum_flags &= ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
856 }
857
858 /*
859 * Too large for interface; fragment if possible.
860 * Must be able to put at least 8 bytes per fragment.
861 */
862 if (ntohs(ip->ip_off) & IP_DF) {
863 if (flags & IP_RETURNMTU)
864 *mtu_p = mtu;
865 error = EMSGSIZE;
866 IP_STATINC(IP_STAT_CANTFRAG);
867 goto bad;
868 }
869
870 error = ip_fragment(m, ifp, mtu);
871 if (error) {
872 m = NULL;
873 goto bad;
874 }
875
876 for (; m; m = m0) {
877 m0 = m->m_nextpkt;
878 m->m_nextpkt = 0;
879 if (error == 0) {
880 #if IFA_STATS
881 if (ia)
882 ia->ia_ifa.ifa_data.ifad_outbytes +=
883 ntohs(ip->ip_len);
884 #endif
885 #ifdef IPSEC
886 /* clean ipsec history once it goes out of the node */
887 ipsec_delaux(m);
888 #endif /* IPSEC */
889
890 #ifdef IPSEC_NAT_T
891 /*
892 * If we get there, the packet has not been handeld by
893 * IPSec whereas it should have. Now that it has been
894 * fragmented, re-inject it in ip_output so that IPsec
895 * processing can occur.
896 */
897 if (natt_frag) {
898 error = ip_output(m, opt,
899 ro, flags, imo, so, mtu_p);
900 } else
901 #endif /* IPSEC_NAT_T */
902 {
903 KASSERT((m->m_pkthdr.csum_flags &
904 (M_CSUM_UDPv4 | M_CSUM_TCPv4)) == 0);
905 error = (*ifp->if_output)(ifp, m,
906 (m->m_flags & M_MCAST) ?
907 sintocsa(rdst) : sintocsa(dst),
908 rt);
909 }
910 } else
911 m_freem(m);
912 }
913
914 if (error == 0)
915 IP_STATINC(IP_STAT_FRAGMENTED);
916 done:
917 rtcache_free(&iproute);
918
919 #ifdef IPSEC
920 if (sp != NULL) {
921 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
922 printf("DP ip_output call free SP:%p\n", sp));
923 key_freesp(sp);
924 }
925 #endif /* IPSEC */
926 #ifdef FAST_IPSEC
927 if (sp != NULL)
928 KEY_FREESP(&sp);
929 #endif /* FAST_IPSEC */
930
931 return (error);
932 bad:
933 m_freem(m);
934 goto done;
935 }
936
937 int
938 ip_fragment(struct mbuf *m, struct ifnet *ifp, u_long mtu)
939 {
940 struct ip *ip, *mhip;
941 struct mbuf *m0;
942 int len, hlen, off;
943 int mhlen, firstlen;
944 struct mbuf **mnext;
945 int sw_csum = m->m_pkthdr.csum_flags;
946 int fragments = 0;
947 int s;
948 int error = 0;
949
950 ip = mtod(m, struct ip *);
951 hlen = ip->ip_hl << 2;
952 if (ifp != NULL)
953 sw_csum &= ~ifp->if_csum_flags_tx;
954
955 len = (mtu - hlen) &~ 7;
956 if (len < 8) {
957 m_freem(m);
958 return (EMSGSIZE);
959 }
960
961 firstlen = len;
962 mnext = &m->m_nextpkt;
963
964 /*
965 * Loop through length of segment after first fragment,
966 * make new header and copy data of each part and link onto chain.
967 */
968 m0 = m;
969 mhlen = sizeof (struct ip);
970 for (off = hlen + len; off < ntohs(ip->ip_len); off += len) {
971 MGETHDR(m, M_DONTWAIT, MT_HEADER);
972 if (m == 0) {
973 error = ENOBUFS;
974 IP_STATINC(IP_STAT_ODROPPED);
975 goto sendorfree;
976 }
977 MCLAIM(m, m0->m_owner);
978 *mnext = m;
979 mnext = &m->m_nextpkt;
980 m->m_data += max_linkhdr;
981 mhip = mtod(m, struct ip *);
982 *mhip = *ip;
983 /* we must inherit MCAST and BCAST flags */
984 m->m_flags |= m0->m_flags & (M_MCAST|M_BCAST);
985 if (hlen > sizeof (struct ip)) {
986 mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
987 mhip->ip_hl = mhlen >> 2;
988 }
989 m->m_len = mhlen;
990 mhip->ip_off = ((off - hlen) >> 3) +
991 (ntohs(ip->ip_off) & ~IP_MF);
992 if (ip->ip_off & htons(IP_MF))
993 mhip->ip_off |= IP_MF;
994 if (off + len >= ntohs(ip->ip_len))
995 len = ntohs(ip->ip_len) - off;
996 else
997 mhip->ip_off |= IP_MF;
998 HTONS(mhip->ip_off);
999 mhip->ip_len = htons((u_int16_t)(len + mhlen));
1000 m->m_next = m_copym(m0, off, len, M_DONTWAIT);
1001 if (m->m_next == 0) {
1002 error = ENOBUFS; /* ??? */
1003 IP_STATINC(IP_STAT_ODROPPED);
1004 goto sendorfree;
1005 }
1006 m->m_pkthdr.len = mhlen + len;
1007 m->m_pkthdr.rcvif = (struct ifnet *)0;
1008 mhip->ip_sum = 0;
1009 if (sw_csum & M_CSUM_IPv4) {
1010 mhip->ip_sum = in_cksum(m, mhlen);
1011 KASSERT((m->m_pkthdr.csum_flags & M_CSUM_IPv4) == 0);
1012 } else {
1013 m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
1014 m->m_pkthdr.csum_data |= mhlen << 16;
1015 }
1016 IP_STATINC(IP_STAT_OFRAGMENTS);
1017 fragments++;
1018 }
1019 /*
1020 * Update first fragment by trimming what's been copied out
1021 * and updating header, then send each fragment (in order).
1022 */
1023 m = m0;
1024 m_adj(m, hlen + firstlen - ntohs(ip->ip_len));
1025 m->m_pkthdr.len = hlen + firstlen;
1026 ip->ip_len = htons((u_int16_t)m->m_pkthdr.len);
1027 ip->ip_off |= htons(IP_MF);
1028 ip->ip_sum = 0;
1029 if (sw_csum & M_CSUM_IPv4) {
1030 ip->ip_sum = in_cksum(m, hlen);
1031 m->m_pkthdr.csum_flags &= ~M_CSUM_IPv4;
1032 } else {
1033 KASSERT(m->m_pkthdr.csum_flags & M_CSUM_IPv4);
1034 KASSERT(M_CSUM_DATA_IPv4_IPHL(m->m_pkthdr.csum_data) >=
1035 sizeof(struct ip));
1036 }
1037 sendorfree:
1038 /*
1039 * If there is no room for all the fragments, don't queue
1040 * any of them.
1041 */
1042 if (ifp != NULL) {
1043 s = splnet();
1044 if (ifp->if_snd.ifq_maxlen - ifp->if_snd.ifq_len < fragments &&
1045 error == 0) {
1046 error = ENOBUFS;
1047 IP_STATINC(IP_STAT_ODROPPED);
1048 IFQ_INC_DROPS(&ifp->if_snd);
1049 }
1050 splx(s);
1051 }
1052 if (error) {
1053 for (m = m0; m; m = m0) {
1054 m0 = m->m_nextpkt;
1055 m->m_nextpkt = NULL;
1056 m_freem(m);
1057 }
1058 }
1059 return (error);
1060 }
1061
1062 /*
1063 * Process a delayed payload checksum calculation.
1064 */
1065 void
1066 in_delayed_cksum(struct mbuf *m)
1067 {
1068 struct ip *ip;
1069 u_int16_t csum, offset;
1070
1071 ip = mtod(m, struct ip *);
1072 offset = ip->ip_hl << 2;
1073 csum = in4_cksum(m, 0, offset, ntohs(ip->ip_len) - offset);
1074 if (csum == 0 && (m->m_pkthdr.csum_flags & M_CSUM_UDPv4) != 0)
1075 csum = 0xffff;
1076
1077 offset += M_CSUM_DATA_IPv4_OFFSET(m->m_pkthdr.csum_data);
1078
1079 if ((offset + sizeof(u_int16_t)) > m->m_len) {
1080 /* This happen when ip options were inserted
1081 printf("in_delayed_cksum: pullup len %d off %d proto %d\n",
1082 m->m_len, offset, ip->ip_p);
1083 */
1084 m_copyback(m, offset, sizeof(csum), (void *) &csum);
1085 } else
1086 *(u_int16_t *)(mtod(m, char *) + offset) = csum;
1087 }
1088
1089 /*
1090 * Determine the maximum length of the options to be inserted;
1091 * we would far rather allocate too much space rather than too little.
1092 */
1093
1094 u_int
1095 ip_optlen(struct inpcb *inp)
1096 {
1097 struct mbuf *m = inp->inp_options;
1098
1099 if (m && m->m_len > offsetof(struct ipoption, ipopt_dst))
1100 return (m->m_len - offsetof(struct ipoption, ipopt_dst));
1101 else
1102 return 0;
1103 }
1104
1105
1106 /*
1107 * Insert IP options into preformed packet.
1108 * Adjust IP destination as required for IP source routing,
1109 * as indicated by a non-zero in_addr at the start of the options.
1110 */
1111 static struct mbuf *
1112 ip_insertoptions(struct mbuf *m, struct mbuf *opt, int *phlen)
1113 {
1114 struct ipoption *p = mtod(opt, struct ipoption *);
1115 struct mbuf *n;
1116 struct ip *ip = mtod(m, struct ip *);
1117 unsigned optlen;
1118
1119 optlen = opt->m_len - sizeof(p->ipopt_dst);
1120 if (optlen + ntohs(ip->ip_len) > IP_MAXPACKET)
1121 return (m); /* XXX should fail */
1122 if (!in_nullhost(p->ipopt_dst))
1123 ip->ip_dst = p->ipopt_dst;
1124 if (M_READONLY(m) || M_LEADINGSPACE(m) < optlen) {
1125 MGETHDR(n, M_DONTWAIT, MT_HEADER);
1126 if (n == 0)
1127 return (m);
1128 MCLAIM(n, m->m_owner);
1129 M_MOVE_PKTHDR(n, m);
1130 m->m_len -= sizeof(struct ip);
1131 m->m_data += sizeof(struct ip);
1132 n->m_next = m;
1133 m = n;
1134 m->m_len = optlen + sizeof(struct ip);
1135 m->m_data += max_linkhdr;
1136 bcopy((void *)ip, mtod(m, void *), sizeof(struct ip));
1137 } else {
1138 m->m_data -= optlen;
1139 m->m_len += optlen;
1140 memmove(mtod(m, void *), ip, sizeof(struct ip));
1141 }
1142 m->m_pkthdr.len += optlen;
1143 ip = mtod(m, struct ip *);
1144 bcopy((void *)p->ipopt_list, (void *)(ip + 1), (unsigned)optlen);
1145 *phlen = sizeof(struct ip) + optlen;
1146 ip->ip_len = htons(ntohs(ip->ip_len) + optlen);
1147 return (m);
1148 }
1149
1150 /*
1151 * Copy options from ip to jp,
1152 * omitting those not copied during fragmentation.
1153 */
1154 int
1155 ip_optcopy(struct ip *ip, struct ip *jp)
1156 {
1157 u_char *cp, *dp;
1158 int opt, optlen, cnt;
1159
1160 cp = (u_char *)(ip + 1);
1161 dp = (u_char *)(jp + 1);
1162 cnt = (ip->ip_hl << 2) - sizeof (struct ip);
1163 for (; cnt > 0; cnt -= optlen, cp += optlen) {
1164 opt = cp[0];
1165 if (opt == IPOPT_EOL)
1166 break;
1167 if (opt == IPOPT_NOP) {
1168 /* Preserve for IP mcast tunnel's LSRR alignment. */
1169 *dp++ = IPOPT_NOP;
1170 optlen = 1;
1171 continue;
1172 }
1173 #ifdef DIAGNOSTIC
1174 if (cnt < IPOPT_OLEN + sizeof(*cp))
1175 panic("malformed IPv4 option passed to ip_optcopy");
1176 #endif
1177 optlen = cp[IPOPT_OLEN];
1178 #ifdef DIAGNOSTIC
1179 if (optlen < IPOPT_OLEN + sizeof(*cp) || optlen > cnt)
1180 panic("malformed IPv4 option passed to ip_optcopy");
1181 #endif
1182 /* bogus lengths should have been caught by ip_dooptions */
1183 if (optlen > cnt)
1184 optlen = cnt;
1185 if (IPOPT_COPIED(opt)) {
1186 bcopy((void *)cp, (void *)dp, (unsigned)optlen);
1187 dp += optlen;
1188 }
1189 }
1190 for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
1191 *dp++ = IPOPT_EOL;
1192 return (optlen);
1193 }
1194
1195 /*
1196 * IP socket option processing.
1197 */
1198 int
1199 ip_ctloutput(int op, struct socket *so, struct sockopt *sopt)
1200 {
1201 struct inpcb *inp = sotoinpcb(so);
1202 int optval = 0;
1203 int error = 0;
1204 #if defined(IPSEC) || defined(FAST_IPSEC)
1205 struct lwp *l = curlwp; /*XXX*/
1206 #endif
1207
1208 if (sopt->sopt_level != IPPROTO_IP) {
1209 if (sopt->sopt_level == SOL_SOCKET && sopt->sopt_name == SO_NOHEADER)
1210 return 0;
1211 return ENOPROTOOPT;
1212 }
1213
1214 switch (op) {
1215 case PRCO_SETOPT:
1216 switch (sopt->sopt_name) {
1217 case IP_OPTIONS:
1218 #ifdef notyet
1219 case IP_RETOPTS:
1220 #endif
1221 error = ip_pcbopts(&inp->inp_options, sopt);
1222 break;
1223
1224 case IP_TOS:
1225 case IP_TTL:
1226 case IP_RECVOPTS:
1227 case IP_RECVRETOPTS:
1228 case IP_RECVDSTADDR:
1229 case IP_RECVIF:
1230 error = sockopt_getint(sopt, &optval);
1231 if (error)
1232 break;
1233
1234 switch (sopt->sopt_name) {
1235 case IP_TOS:
1236 inp->inp_ip.ip_tos = optval;
1237 break;
1238
1239 case IP_TTL:
1240 inp->inp_ip.ip_ttl = optval;
1241 break;
1242 #define OPTSET(bit) \
1243 if (optval) \
1244 inp->inp_flags |= bit; \
1245 else \
1246 inp->inp_flags &= ~bit;
1247
1248 case IP_RECVOPTS:
1249 OPTSET(INP_RECVOPTS);
1250 break;
1251
1252 case IP_RECVRETOPTS:
1253 OPTSET(INP_RECVRETOPTS);
1254 break;
1255
1256 case IP_RECVDSTADDR:
1257 OPTSET(INP_RECVDSTADDR);
1258 break;
1259
1260 case IP_RECVIF:
1261 OPTSET(INP_RECVIF);
1262 break;
1263 }
1264 break;
1265 #undef OPTSET
1266
1267 case IP_MULTICAST_IF:
1268 case IP_MULTICAST_TTL:
1269 case IP_MULTICAST_LOOP:
1270 case IP_ADD_MEMBERSHIP:
1271 case IP_DROP_MEMBERSHIP:
1272 error = ip_setmoptions(&inp->inp_moptions, sopt);
1273 break;
1274
1275 case IP_PORTRANGE:
1276 error = sockopt_getint(sopt, &optval);
1277 if (error)
1278 break;
1279
1280 /* INP_LOCK(inp); */
1281 switch (optval) {
1282 case IP_PORTRANGE_DEFAULT:
1283 case IP_PORTRANGE_HIGH:
1284 inp->inp_flags &= ~(INP_LOWPORT);
1285 break;
1286
1287 case IP_PORTRANGE_LOW:
1288 inp->inp_flags |= INP_LOWPORT;
1289 break;
1290
1291 default:
1292 error = EINVAL;
1293 break;
1294 }
1295 /* INP_UNLOCK(inp); */
1296 break;
1297
1298 #if defined(IPSEC) || defined(FAST_IPSEC)
1299 case IP_IPSEC_POLICY:
1300 {
1301 int priv = 0;
1302
1303 #ifdef __NetBSD__
1304 if (l == 0 || kauth_authorize_generic(l->l_cred,
1305 KAUTH_GENERIC_ISSUSER, NULL))
1306 priv = 0;
1307 else
1308 priv = 1;
1309 #else
1310 priv = (in6p->in6p_socket->so_state & SS_PRIV);
1311 #endif
1312
1313 error = ipsec4_set_policy(inp, sopt->sopt_name,
1314 sopt->sopt_data, sopt->sopt_size, priv);
1315 break;
1316 }
1317 #endif /*IPSEC*/
1318
1319 default:
1320 error = ENOPROTOOPT;
1321 break;
1322 }
1323 break;
1324
1325 case PRCO_GETOPT:
1326 switch (sopt->sopt_name) {
1327 case IP_OPTIONS:
1328 case IP_RETOPTS:
1329 if (inp->inp_options) {
1330 struct mbuf *m;
1331
1332 m = m_copym(inp->inp_options, 0, M_COPYALL,
1333 M_DONTWAIT);
1334 if (m == NULL) {
1335 error = ENOBUFS;
1336 break;
1337 }
1338
1339 error = sockopt_setmbuf(sopt, m);
1340 }
1341 break;
1342
1343 case IP_TOS:
1344 case IP_TTL:
1345 case IP_RECVOPTS:
1346 case IP_RECVRETOPTS:
1347 case IP_RECVDSTADDR:
1348 case IP_RECVIF:
1349 case IP_ERRORMTU:
1350 switch (sopt->sopt_name) {
1351 case IP_TOS:
1352 optval = inp->inp_ip.ip_tos;
1353 break;
1354
1355 case IP_TTL:
1356 optval = inp->inp_ip.ip_ttl;
1357 break;
1358
1359 case IP_ERRORMTU:
1360 optval = inp->inp_errormtu;
1361 break;
1362
1363 #define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
1364
1365 case IP_RECVOPTS:
1366 optval = OPTBIT(INP_RECVOPTS);
1367 break;
1368
1369 case IP_RECVRETOPTS:
1370 optval = OPTBIT(INP_RECVRETOPTS);
1371 break;
1372
1373 case IP_RECVDSTADDR:
1374 optval = OPTBIT(INP_RECVDSTADDR);
1375 break;
1376
1377 case IP_RECVIF:
1378 optval = OPTBIT(INP_RECVIF);
1379 break;
1380 }
1381 error = sockopt_setint(sopt, optval);
1382 break;
1383
1384 #if 0 /* defined(IPSEC) || defined(FAST_IPSEC) */
1385 case IP_IPSEC_POLICY:
1386 {
1387 struct mbuf *m = NULL;
1388
1389 /* XXX this will return EINVAL as sopt is empty */
1390 error = ipsec4_get_policy(inp, sopt->sopt_data,
1391 sopt->sopt_size, &m);
1392 if (error == 0)
1393 error = sockopt_setmbuf(sopt, m);
1394 break;
1395 }
1396 #endif /*IPSEC*/
1397
1398 case IP_MULTICAST_IF:
1399 case IP_MULTICAST_TTL:
1400 case IP_MULTICAST_LOOP:
1401 case IP_ADD_MEMBERSHIP:
1402 case IP_DROP_MEMBERSHIP:
1403 error = ip_getmoptions(inp->inp_moptions, sopt);
1404 break;
1405
1406 case IP_PORTRANGE:
1407 if (inp->inp_flags & INP_LOWPORT)
1408 optval = IP_PORTRANGE_LOW;
1409 else
1410 optval = IP_PORTRANGE_DEFAULT;
1411
1412 error = sockopt_setint(sopt, optval);
1413
1414 break;
1415
1416 default:
1417 error = ENOPROTOOPT;
1418 break;
1419 }
1420 break;
1421 }
1422 return (error);
1423 }
1424
1425 /*
1426 * Set up IP options in pcb for insertion in output packets.
1427 * Store in mbuf with pointer in pcbopt, adding pseudo-option
1428 * with destination address if source routed.
1429 */
1430 int
1431 ip_pcbopts(struct mbuf **pcbopt, const struct sockopt *sopt)
1432 {
1433 struct mbuf *m;
1434 const u_char *cp;
1435 u_char *dp;
1436 int cnt;
1437 uint8_t optval, olen, offset;
1438
1439 /* turn off any old options */
1440 if (*pcbopt)
1441 (void)m_free(*pcbopt);
1442 *pcbopt = NULL;
1443
1444 cp = sopt->sopt_data;
1445 cnt = sopt->sopt_size;
1446
1447 if (cnt == 0)
1448 return (0); /* Only turning off any previous options */
1449
1450 #ifndef __vax__
1451 if (cnt % sizeof(int32_t))
1452 return (EINVAL);
1453 #endif
1454
1455 m = m_get(M_DONTWAIT, MT_SOOPTS);
1456 if (m == NULL)
1457 return (ENOBUFS);
1458
1459 dp = mtod(m, u_char *);
1460 memset(dp, 0, sizeof(struct in_addr));
1461 dp += sizeof(struct in_addr);
1462 m->m_len = sizeof(struct in_addr);
1463
1464 /*
1465 * IP option list according to RFC791. Each option is of the form
1466 *
1467 * [optval] [olen] [(olen - 2) data bytes]
1468 *
1469 * we validate the list and copy options to an mbuf for prepending
1470 * to data packets. The IP first-hop destination address will be
1471 * stored before actual options and is zero if unset.
1472 */
1473 while (cnt > 0) {
1474 optval = cp[IPOPT_OPTVAL];
1475
1476 if (optval == IPOPT_EOL || optval == IPOPT_NOP) {
1477 olen = 1;
1478 } else {
1479 if (cnt < IPOPT_OLEN + 1)
1480 goto bad;
1481
1482 olen = cp[IPOPT_OLEN];
1483 if (olen < IPOPT_OLEN + 1 || olen > cnt)
1484 goto bad;
1485 }
1486
1487 if (optval == IPOPT_LSRR || optval == IPOPT_SSRR) {
1488 /*
1489 * user process specifies route as:
1490 * ->A->B->C->D
1491 * D must be our final destination (but we can't
1492 * check that since we may not have connected yet).
1493 * A is first hop destination, which doesn't appear in
1494 * actual IP option, but is stored before the options.
1495 */
1496 if (olen < IPOPT_OFFSET + 1 + sizeof(struct in_addr))
1497 goto bad;
1498
1499 offset = cp[IPOPT_OFFSET];
1500 memcpy(mtod(m, u_char *), cp + IPOPT_OFFSET + 1,
1501 sizeof(struct in_addr));
1502
1503 cp += sizeof(struct in_addr);
1504 cnt -= sizeof(struct in_addr);
1505 olen -= sizeof(struct in_addr);
1506
1507 if (m->m_len + olen > MAX_IPOPTLEN + sizeof(struct in_addr))
1508 goto bad;
1509
1510 memcpy(dp, cp, olen);
1511 dp[IPOPT_OPTVAL] = optval;
1512 dp[IPOPT_OLEN] = olen;
1513 dp[IPOPT_OFFSET] = offset;
1514 break;
1515 } else {
1516 if (m->m_len + olen > MAX_IPOPTLEN + sizeof(struct in_addr))
1517 goto bad;
1518
1519 memcpy(dp, cp, olen);
1520 break;
1521 }
1522
1523 dp += olen;
1524 m->m_len += olen;
1525
1526 if (optval == IPOPT_EOL)
1527 break;
1528
1529 cp += olen;
1530 cnt -= olen;
1531 }
1532
1533 *pcbopt = m;
1534 return (0);
1535
1536 bad:
1537 (void)m_free(m);
1538 return (EINVAL);
1539 }
1540
1541 /*
1542 * following RFC1724 section 3.3, 0.0.0.0/8 is interpreted as interface index.
1543 */
1544 static struct ifnet *
1545 ip_multicast_if(struct in_addr *a, int *ifindexp)
1546 {
1547 int ifindex;
1548 struct ifnet *ifp = NULL;
1549 struct in_ifaddr *ia;
1550
1551 if (ifindexp)
1552 *ifindexp = 0;
1553 if (ntohl(a->s_addr) >> 24 == 0) {
1554 ifindex = ntohl(a->s_addr) & 0xffffff;
1555 if (ifindex < 0 || if_indexlim <= ifindex)
1556 return NULL;
1557 ifp = ifindex2ifnet[ifindex];
1558 if (!ifp)
1559 return NULL;
1560 if (ifindexp)
1561 *ifindexp = ifindex;
1562 } else {
1563 LIST_FOREACH(ia, &IN_IFADDR_HASH(a->s_addr), ia_hash) {
1564 if (in_hosteq(ia->ia_addr.sin_addr, *a) &&
1565 (ia->ia_ifp->if_flags & IFF_MULTICAST) != 0) {
1566 ifp = ia->ia_ifp;
1567 break;
1568 }
1569 }
1570 }
1571 return ifp;
1572 }
1573
1574 static int
1575 ip_getoptval(const struct sockopt *sopt, u_int8_t *val, u_int maxval)
1576 {
1577 u_int tval;
1578 u_char cval;
1579 int error;
1580
1581 if (sopt == NULL)
1582 return EINVAL;
1583
1584 switch (sopt->sopt_size) {
1585 case sizeof(u_char):
1586 error = sockopt_get(sopt, &cval, sizeof(u_char));
1587 tval = cval;
1588 break;
1589
1590 case sizeof(u_int):
1591 error = sockopt_get(sopt, &tval, sizeof(u_int));
1592 break;
1593
1594 default:
1595 error = EINVAL;
1596 }
1597
1598 if (error)
1599 return error;
1600
1601 if (tval > maxval)
1602 return EINVAL;
1603
1604 *val = tval;
1605 return 0;
1606 }
1607
1608 /*
1609 * Set the IP multicast options in response to user setsockopt().
1610 */
1611 int
1612 ip_setmoptions(struct ip_moptions **imop, const struct sockopt *sopt)
1613 {
1614 int error = 0;
1615 int i;
1616 struct in_addr addr;
1617 struct ip_mreq lmreq, *mreq;
1618 struct ifnet *ifp;
1619 struct ip_moptions *imo = *imop;
1620 int ifindex;
1621
1622 if (imo == NULL) {
1623 /*
1624 * No multicast option buffer attached to the pcb;
1625 * allocate one and initialize to default values.
1626 */
1627 imo = malloc(sizeof(*imo), M_IPMOPTS, M_NOWAIT);
1628 if (imo == NULL)
1629 return (ENOBUFS);
1630
1631 *imop = imo;
1632 imo->imo_multicast_ifp = NULL;
1633 imo->imo_multicast_addr.s_addr = INADDR_ANY;
1634 imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
1635 imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
1636 imo->imo_num_memberships = 0;
1637 }
1638
1639 switch (sopt->sopt_name) {
1640 case IP_MULTICAST_IF:
1641 /*
1642 * Select the interface for outgoing multicast packets.
1643 */
1644 error = sockopt_get(sopt, &addr, sizeof(addr));
1645 if (error)
1646 break;
1647
1648 /*
1649 * INADDR_ANY is used to remove a previous selection.
1650 * When no interface is selected, a default one is
1651 * chosen every time a multicast packet is sent.
1652 */
1653 if (in_nullhost(addr)) {
1654 imo->imo_multicast_ifp = NULL;
1655 break;
1656 }
1657 /*
1658 * The selected interface is identified by its local
1659 * IP address. Find the interface and confirm that
1660 * it supports multicasting.
1661 */
1662 ifp = ip_multicast_if(&addr, &ifindex);
1663 if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
1664 error = EADDRNOTAVAIL;
1665 break;
1666 }
1667 imo->imo_multicast_ifp = ifp;
1668 if (ifindex)
1669 imo->imo_multicast_addr = addr;
1670 else
1671 imo->imo_multicast_addr.s_addr = INADDR_ANY;
1672 break;
1673
1674 case IP_MULTICAST_TTL:
1675 /*
1676 * Set the IP time-to-live for outgoing multicast packets.
1677 */
1678 error = ip_getoptval(sopt, &imo->imo_multicast_ttl, MAXTTL);
1679 break;
1680
1681 case IP_MULTICAST_LOOP:
1682 /*
1683 * Set the loopback flag for outgoing multicast packets.
1684 * Must be zero or one.
1685 */
1686 error = ip_getoptval(sopt, &imo->imo_multicast_loop, 1);
1687 break;
1688
1689 case IP_ADD_MEMBERSHIP:
1690 /*
1691 * Add a multicast group membership.
1692 * Group must be a valid IP multicast address.
1693 */
1694 error = sockopt_get(sopt, &lmreq, sizeof(lmreq));
1695 if (error)
1696 break;
1697
1698 mreq = &lmreq;
1699
1700 if (!IN_MULTICAST(mreq->imr_multiaddr.s_addr)) {
1701 error = EINVAL;
1702 break;
1703 }
1704 /*
1705 * If no interface address was provided, use the interface of
1706 * the route to the given multicast address.
1707 */
1708 if (in_nullhost(mreq->imr_interface)) {
1709 struct rtentry *rt;
1710 union {
1711 struct sockaddr dst;
1712 struct sockaddr_in dst4;
1713 } u;
1714 struct route ro;
1715
1716 memset(&ro, 0, sizeof(ro));
1717
1718 sockaddr_in_init(&u.dst4, &mreq->imr_multiaddr, 0);
1719 rtcache_setdst(&ro, &u.dst);
1720 ifp = (rt = rtcache_init(&ro)) != NULL ? rt->rt_ifp
1721 : NULL;
1722 rtcache_free(&ro);
1723 } else {
1724 ifp = ip_multicast_if(&mreq->imr_interface, NULL);
1725 }
1726 /*
1727 * See if we found an interface, and confirm that it
1728 * supports multicast.
1729 */
1730 if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
1731 error = EADDRNOTAVAIL;
1732 break;
1733 }
1734 /*
1735 * See if the membership already exists or if all the
1736 * membership slots are full.
1737 */
1738 for (i = 0; i < imo->imo_num_memberships; ++i) {
1739 if (imo->imo_membership[i]->inm_ifp == ifp &&
1740 in_hosteq(imo->imo_membership[i]->inm_addr,
1741 mreq->imr_multiaddr))
1742 break;
1743 }
1744 if (i < imo->imo_num_memberships) {
1745 error = EADDRINUSE;
1746 break;
1747 }
1748 if (i == IP_MAX_MEMBERSHIPS) {
1749 error = ETOOMANYREFS;
1750 break;
1751 }
1752 /*
1753 * Everything looks good; add a new record to the multicast
1754 * address list for the given interface.
1755 */
1756 if ((imo->imo_membership[i] =
1757 in_addmulti(&mreq->imr_multiaddr, ifp)) == NULL) {
1758 error = ENOBUFS;
1759 break;
1760 }
1761 ++imo->imo_num_memberships;
1762 break;
1763
1764 case IP_DROP_MEMBERSHIP:
1765 /*
1766 * Drop a multicast group membership.
1767 * Group must be a valid IP multicast address.
1768 */
1769 error = sockopt_get(sopt, &lmreq, sizeof(lmreq));
1770 if (error)
1771 break;
1772
1773 mreq = &lmreq;
1774
1775 if (!IN_MULTICAST(mreq->imr_multiaddr.s_addr)) {
1776 error = EINVAL;
1777 break;
1778 }
1779 /*
1780 * If an interface address was specified, get a pointer
1781 * to its ifnet structure.
1782 */
1783 if (in_nullhost(mreq->imr_interface))
1784 ifp = NULL;
1785 else {
1786 ifp = ip_multicast_if(&mreq->imr_interface, NULL);
1787 if (ifp == NULL) {
1788 error = EADDRNOTAVAIL;
1789 break;
1790 }
1791 }
1792 /*
1793 * Find the membership in the membership array.
1794 */
1795 for (i = 0; i < imo->imo_num_memberships; ++i) {
1796 if ((ifp == NULL ||
1797 imo->imo_membership[i]->inm_ifp == ifp) &&
1798 in_hosteq(imo->imo_membership[i]->inm_addr,
1799 mreq->imr_multiaddr))
1800 break;
1801 }
1802 if (i == imo->imo_num_memberships) {
1803 error = EADDRNOTAVAIL;
1804 break;
1805 }
1806 /*
1807 * Give up the multicast address record to which the
1808 * membership points.
1809 */
1810 in_delmulti(imo->imo_membership[i]);
1811 /*
1812 * Remove the gap in the membership array.
1813 */
1814 for (++i; i < imo->imo_num_memberships; ++i)
1815 imo->imo_membership[i-1] = imo->imo_membership[i];
1816 --imo->imo_num_memberships;
1817 break;
1818
1819 default:
1820 error = EOPNOTSUPP;
1821 break;
1822 }
1823
1824 /*
1825 * If all options have default values, no need to keep the mbuf.
1826 */
1827 if (imo->imo_multicast_ifp == NULL &&
1828 imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
1829 imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
1830 imo->imo_num_memberships == 0) {
1831 free(*imop, M_IPMOPTS);
1832 *imop = NULL;
1833 }
1834
1835 return (error);
1836 }
1837
1838 /*
1839 * Return the IP multicast options in response to user getsockopt().
1840 */
1841 int
1842 ip_getmoptions(struct ip_moptions *imo, struct sockopt *sopt)
1843 {
1844 struct in_addr addr;
1845 struct in_ifaddr *ia;
1846 int error;
1847 uint8_t optval;
1848
1849 error = 0;
1850
1851 switch (sopt->sopt_name) {
1852 case IP_MULTICAST_IF:
1853 if (imo == NULL || imo->imo_multicast_ifp == NULL)
1854 addr = zeroin_addr;
1855 else if (imo->imo_multicast_addr.s_addr) {
1856 /* return the value user has set */
1857 addr = imo->imo_multicast_addr;
1858 } else {
1859 IFP_TO_IA(imo->imo_multicast_ifp, ia);
1860 addr = ia ? ia->ia_addr.sin_addr : zeroin_addr;
1861 }
1862 error = sockopt_set(sopt, &addr, sizeof(addr));
1863 break;
1864
1865 case IP_MULTICAST_TTL:
1866 optval = imo ? imo->imo_multicast_ttl
1867 : IP_DEFAULT_MULTICAST_TTL;
1868
1869 error = sockopt_set(sopt, &optval, sizeof(optval));
1870 break;
1871
1872 case IP_MULTICAST_LOOP:
1873 optval = imo ? imo->imo_multicast_loop
1874 : IP_DEFAULT_MULTICAST_LOOP;
1875
1876 error = sockopt_set(sopt, &optval, sizeof(optval));
1877 break;
1878
1879 default:
1880 error = EOPNOTSUPP;
1881 }
1882
1883 return (error);
1884 }
1885
1886 /*
1887 * Discard the IP multicast options.
1888 */
1889 void
1890 ip_freemoptions(struct ip_moptions *imo)
1891 {
1892 int i;
1893
1894 if (imo != NULL) {
1895 for (i = 0; i < imo->imo_num_memberships; ++i)
1896 in_delmulti(imo->imo_membership[i]);
1897 free(imo, M_IPMOPTS);
1898 }
1899 }
1900
1901 /*
1902 * Routine called from ip_output() to loop back a copy of an IP multicast
1903 * packet to the input queue of a specified interface. Note that this
1904 * calls the output routine of the loopback "driver", but with an interface
1905 * pointer that might NOT be lo0ifp -- easier than replicating that code here.
1906 */
1907 static void
1908 ip_mloopback(struct ifnet *ifp, struct mbuf *m, const struct sockaddr_in *dst)
1909 {
1910 struct ip *ip;
1911 struct mbuf *copym;
1912
1913 copym = m_copypacket(m, M_DONTWAIT);
1914 if (copym != NULL
1915 && (copym->m_flags & M_EXT || copym->m_len < sizeof(struct ip)))
1916 copym = m_pullup(copym, sizeof(struct ip));
1917 if (copym == NULL)
1918 return;
1919 /*
1920 * We don't bother to fragment if the IP length is greater
1921 * than the interface's MTU. Can this possibly matter?
1922 */
1923 ip = mtod(copym, struct ip *);
1924
1925 if (copym->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
1926 in_delayed_cksum(copym);
1927 copym->m_pkthdr.csum_flags &=
1928 ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
1929 }
1930
1931 ip->ip_sum = 0;
1932 ip->ip_sum = in_cksum(copym, ip->ip_hl << 2);
1933 (void)looutput(ifp, copym, sintocsa(dst), NULL);
1934 }
Cache object: 53d08b51b7ac72badba5d52df2d2e741
|