1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1986, 1988, 1990, 1993
5 * The Regents of the University of California. 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 University 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 REGENTS 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 REGENTS 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 * @(#)ip_output.c 8.3 (Berkeley) 1/21/94
32 */
33
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36
37 #include "opt_inet.h"
38 #include "opt_ipsec.h"
39 #include "opt_kern_tls.h"
40 #include "opt_mbuf_stress_test.h"
41 #include "opt_ratelimit.h"
42 #include "opt_route.h"
43 #include "opt_rss.h"
44 #include "opt_sctp.h"
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/kernel.h>
49 #include <sys/ktls.h>
50 #include <sys/lock.h>
51 #include <sys/malloc.h>
52 #include <sys/mbuf.h>
53 #include <sys/priv.h>
54 #include <sys/proc.h>
55 #include <sys/protosw.h>
56 #include <sys/sdt.h>
57 #include <sys/socket.h>
58 #include <sys/socketvar.h>
59 #include <sys/sysctl.h>
60 #include <sys/ucred.h>
61
62 #include <net/if.h>
63 #include <net/if_var.h>
64 #include <net/if_vlan_var.h>
65 #include <net/if_llatbl.h>
66 #include <net/ethernet.h>
67 #include <net/netisr.h>
68 #include <net/pfil.h>
69 #include <net/route.h>
70 #include <net/route/nhop.h>
71 #include <net/rss_config.h>
72 #include <net/vnet.h>
73
74 #include <netinet/in.h>
75 #include <netinet/in_fib.h>
76 #include <netinet/in_kdtrace.h>
77 #include <netinet/in_systm.h>
78 #include <netinet/ip.h>
79 #include <netinet/in_fib.h>
80 #include <netinet/in_pcb.h>
81 #include <netinet/in_rss.h>
82 #include <netinet/in_var.h>
83 #include <netinet/ip_var.h>
84 #include <netinet/ip_options.h>
85
86 #include <netinet/udp.h>
87 #include <netinet/udp_var.h>
88
89 #if defined(SCTP) || defined(SCTP_SUPPORT)
90 #include <netinet/sctp.h>
91 #include <netinet/sctp_crc32.h>
92 #endif
93
94 #include <netipsec/ipsec_support.h>
95
96 #include <machine/in_cksum.h>
97
98 #include <security/mac/mac_framework.h>
99
100 #ifdef MBUF_STRESS_TEST
101 static int mbuf_frag_size = 0;
102 SYSCTL_INT(_net_inet_ip, OID_AUTO, mbuf_frag_size, CTLFLAG_RW,
103 &mbuf_frag_size, 0, "Fragment outgoing mbufs to this size");
104 #endif
105
106 static void ip_mloopback(struct ifnet *, const struct mbuf *, int);
107
108 extern int in_mcast_loop;
109
110 static inline int
111 ip_output_pfil(struct mbuf **mp, struct ifnet *ifp, int flags,
112 struct inpcb *inp, struct sockaddr_in *dst, int *fibnum, int *error)
113 {
114 struct m_tag *fwd_tag = NULL;
115 struct mbuf *m;
116 struct in_addr odst;
117 struct ip *ip;
118 int pflags = PFIL_OUT;
119
120 m = *mp;
121 ip = mtod(m, struct ip *);
122
123 /* Run through list of hooks for output packets. */
124 odst.s_addr = ip->ip_dst.s_addr;
125 switch (pfil_run_hooks(V_inet_pfil_head, mp, ifp, pflags, inp)) {
126 case PFIL_DROPPED:
127 *error = EACCES;
128 /* FALLTHROUGH */
129 case PFIL_CONSUMED:
130 return 1; /* Finished */
131 case PFIL_PASS:
132 *error = 0;
133 }
134 m = *mp;
135 ip = mtod(m, struct ip *);
136
137 /* See if destination IP address was changed by packet filter. */
138 if (odst.s_addr != ip->ip_dst.s_addr) {
139 m->m_flags |= M_SKIP_FIREWALL;
140 /* If destination is now ourself drop to ip_input(). */
141 if (in_localip(ip->ip_dst)) {
142 m->m_flags |= M_FASTFWD_OURS;
143 if (m->m_pkthdr.rcvif == NULL)
144 m->m_pkthdr.rcvif = V_loif;
145 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
146 m->m_pkthdr.csum_flags |=
147 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
148 m->m_pkthdr.csum_data = 0xffff;
149 }
150 m->m_pkthdr.csum_flags |=
151 CSUM_IP_CHECKED | CSUM_IP_VALID;
152 #if defined(SCTP) || defined(SCTP_SUPPORT)
153 if (m->m_pkthdr.csum_flags & CSUM_SCTP)
154 m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
155 #endif
156 *error = netisr_queue(NETISR_IP, m);
157 return 1; /* Finished */
158 }
159
160 bzero(dst, sizeof(*dst));
161 dst->sin_family = AF_INET;
162 dst->sin_len = sizeof(*dst);
163 dst->sin_addr = ip->ip_dst;
164
165 return -1; /* Reloop */
166 }
167 /* See if fib was changed by packet filter. */
168 if ((*fibnum) != M_GETFIB(m)) {
169 m->m_flags |= M_SKIP_FIREWALL;
170 *fibnum = M_GETFIB(m);
171 return -1; /* Reloop for FIB change */
172 }
173
174 /* See if local, if yes, send it to netisr with IP_FASTFWD_OURS. */
175 if (m->m_flags & M_FASTFWD_OURS) {
176 if (m->m_pkthdr.rcvif == NULL)
177 m->m_pkthdr.rcvif = V_loif;
178 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
179 m->m_pkthdr.csum_flags |=
180 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
181 m->m_pkthdr.csum_data = 0xffff;
182 }
183 #if defined(SCTP) || defined(SCTP_SUPPORT)
184 if (m->m_pkthdr.csum_flags & CSUM_SCTP)
185 m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
186 #endif
187 m->m_pkthdr.csum_flags |=
188 CSUM_IP_CHECKED | CSUM_IP_VALID;
189
190 *error = netisr_queue(NETISR_IP, m);
191 return 1; /* Finished */
192 }
193 /* Or forward to some other address? */
194 if ((m->m_flags & M_IP_NEXTHOP) &&
195 ((fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL)) {
196 bcopy((fwd_tag+1), dst, sizeof(struct sockaddr_in));
197 m->m_flags |= M_SKIP_FIREWALL;
198 m->m_flags &= ~M_IP_NEXTHOP;
199 m_tag_delete(m, fwd_tag);
200
201 return -1; /* Reloop for CHANGE of dst */
202 }
203
204 return 0;
205 }
206
207 static int
208 ip_output_send(struct inpcb *inp, struct ifnet *ifp, struct mbuf *m,
209 const struct sockaddr *gw, struct route *ro, bool stamp_tag)
210 {
211 #ifdef KERN_TLS
212 struct ktls_session *tls = NULL;
213 #endif
214 struct m_snd_tag *mst;
215 int error;
216
217 MPASS((m->m_pkthdr.csum_flags & CSUM_SND_TAG) == 0);
218 mst = NULL;
219
220 #ifdef KERN_TLS
221 /*
222 * If this is an unencrypted TLS record, save a reference to
223 * the record. This local reference is used to call
224 * ktls_output_eagain after the mbuf has been freed (thus
225 * dropping the mbuf's reference) in if_output.
226 */
227 if (m->m_next != NULL && mbuf_has_tls_session(m->m_next)) {
228 tls = ktls_hold(m->m_next->m_epg_tls);
229 mst = tls->snd_tag;
230
231 /*
232 * If a TLS session doesn't have a valid tag, it must
233 * have had an earlier ifp mismatch, so drop this
234 * packet.
235 */
236 if (mst == NULL) {
237 m_freem(m);
238 error = EAGAIN;
239 goto done;
240 }
241 /*
242 * Always stamp tags that include NIC ktls.
243 */
244 stamp_tag = true;
245 }
246 #endif
247 #ifdef RATELIMIT
248 if (inp != NULL && mst == NULL) {
249 if ((inp->inp_flags2 & INP_RATE_LIMIT_CHANGED) != 0 ||
250 (inp->inp_snd_tag != NULL &&
251 inp->inp_snd_tag->ifp != ifp))
252 in_pcboutput_txrtlmt(inp, ifp, m);
253
254 if (inp->inp_snd_tag != NULL)
255 mst = inp->inp_snd_tag;
256 }
257 #endif
258 if (stamp_tag && mst != NULL) {
259 KASSERT(m->m_pkthdr.rcvif == NULL,
260 ("trying to add a send tag to a forwarded packet"));
261 if (mst->ifp != ifp) {
262 m_freem(m);
263 error = EAGAIN;
264 goto done;
265 }
266
267 /* stamp send tag on mbuf */
268 m->m_pkthdr.snd_tag = m_snd_tag_ref(mst);
269 m->m_pkthdr.csum_flags |= CSUM_SND_TAG;
270 }
271
272 error = (*ifp->if_output)(ifp, m, gw, ro);
273
274 done:
275 /* Check for route change invalidating send tags. */
276 #ifdef KERN_TLS
277 if (tls != NULL) {
278 if (error == EAGAIN)
279 error = ktls_output_eagain(inp, tls);
280 ktls_free(tls);
281 }
282 #endif
283 #ifdef RATELIMIT
284 if (error == EAGAIN)
285 in_pcboutput_eagain(inp);
286 #endif
287 return (error);
288 }
289
290 /* rte<>ro_flags translation */
291 static inline void
292 rt_update_ro_flags(struct route *ro, const struct nhop_object *nh)
293 {
294 int nh_flags = nh->nh_flags;
295
296 ro->ro_flags &= ~ (RT_REJECT|RT_BLACKHOLE|RT_HAS_GW);
297
298 ro->ro_flags |= (nh_flags & NHF_REJECT) ? RT_REJECT : 0;
299 ro->ro_flags |= (nh_flags & NHF_BLACKHOLE) ? RT_BLACKHOLE : 0;
300 ro->ro_flags |= (nh_flags & NHF_GATEWAY) ? RT_HAS_GW : 0;
301 }
302
303 /*
304 * IP output. The packet in mbuf chain m contains a skeletal IP
305 * header (with len, off, ttl, proto, tos, src, dst).
306 * The mbuf chain containing the packet will be freed.
307 * The mbuf opt, if present, will not be freed.
308 * If route ro is present and has ro_rt initialized, route lookup would be
309 * skipped and ro->ro_rt would be used. If ro is present but ro->ro_rt is NULL,
310 * then result of route lookup is stored in ro->ro_rt.
311 *
312 * In the IP forwarding case, the packet will arrive with options already
313 * inserted, so must have a NULL opt pointer.
314 */
315 int
316 ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags,
317 struct ip_moptions *imo, struct inpcb *inp)
318 {
319 struct ip *ip;
320 struct ifnet *ifp = NULL; /* keep compiler happy */
321 struct mbuf *m0;
322 int hlen = sizeof (struct ip);
323 int mtu = 0;
324 int error = 0;
325 int vlan_pcp = -1;
326 struct sockaddr_in *dst;
327 const struct sockaddr *gw;
328 struct in_ifaddr *ia = NULL;
329 struct in_addr src;
330 int isbroadcast;
331 uint16_t ip_len, ip_off;
332 struct route iproute;
333 uint32_t fibnum;
334 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
335 int no_route_but_check_spd = 0;
336 #endif
337
338 M_ASSERTPKTHDR(m);
339 NET_EPOCH_ASSERT();
340
341 if (inp != NULL) {
342 INP_LOCK_ASSERT(inp);
343 M_SETFIB(m, inp->inp_inc.inc_fibnum);
344 if ((flags & IP_NODEFAULTFLOWID) == 0) {
345 m->m_pkthdr.flowid = inp->inp_flowid;
346 M_HASHTYPE_SET(m, inp->inp_flowtype);
347 }
348 if ((inp->inp_flags2 & INP_2PCP_SET) != 0)
349 vlan_pcp = (inp->inp_flags2 & INP_2PCP_MASK) >>
350 INP_2PCP_SHIFT;
351 #ifdef NUMA
352 m->m_pkthdr.numa_domain = inp->inp_numa_domain;
353 #endif
354 }
355
356 if (opt) {
357 int len = 0;
358 m = ip_insertoptions(m, opt, &len);
359 if (len != 0)
360 hlen = len; /* ip->ip_hl is updated above */
361 }
362 ip = mtod(m, struct ip *);
363 ip_len = ntohs(ip->ip_len);
364 ip_off = ntohs(ip->ip_off);
365
366 if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
367 ip->ip_v = IPVERSION;
368 ip->ip_hl = hlen >> 2;
369 ip_fillid(ip);
370 } else {
371 /* Header already set, fetch hlen from there */
372 hlen = ip->ip_hl << 2;
373 }
374 if ((flags & IP_FORWARDING) == 0)
375 IPSTAT_INC(ips_localout);
376
377 /*
378 * dst/gw handling:
379 *
380 * gw is readonly but can point either to dst OR rt_gateway,
381 * therefore we need restore gw if we're redoing lookup.
382 */
383 fibnum = (inp != NULL) ? inp->inp_inc.inc_fibnum : M_GETFIB(m);
384 if (ro == NULL) {
385 ro = &iproute;
386 bzero(ro, sizeof (*ro));
387 }
388 dst = (struct sockaddr_in *)&ro->ro_dst;
389 if (ro->ro_nh == NULL) {
390 dst->sin_family = AF_INET;
391 dst->sin_len = sizeof(*dst);
392 dst->sin_addr = ip->ip_dst;
393 }
394 gw = (const struct sockaddr *)dst;
395 again:
396 /*
397 * Validate route against routing table additions;
398 * a better/more specific route might have been added.
399 */
400 if (inp != NULL && ro->ro_nh != NULL)
401 NH_VALIDATE(ro, &inp->inp_rt_cookie, fibnum);
402 /*
403 * If there is a cached route,
404 * check that it is to the same destination
405 * and is still up. If not, free it and try again.
406 * The address family should also be checked in case of sharing the
407 * cache with IPv6.
408 * Also check whether routing cache needs invalidation.
409 */
410 if (ro->ro_nh != NULL &&
411 ((!NH_IS_VALID(ro->ro_nh)) || dst->sin_family != AF_INET ||
412 dst->sin_addr.s_addr != ip->ip_dst.s_addr))
413 RO_INVALIDATE_CACHE(ro);
414 ia = NULL;
415 /*
416 * If routing to interface only, short circuit routing lookup.
417 * The use of an all-ones broadcast address implies this; an
418 * interface is specified by the broadcast address of an interface,
419 * or the destination address of a ptp interface.
420 */
421 if (flags & IP_SENDONES) {
422 if ((ia = ifatoia(ifa_ifwithbroadaddr(sintosa(dst),
423 M_GETFIB(m)))) == NULL &&
424 (ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst),
425 M_GETFIB(m)))) == NULL) {
426 IPSTAT_INC(ips_noroute);
427 error = ENETUNREACH;
428 goto bad;
429 }
430 ip->ip_dst.s_addr = INADDR_BROADCAST;
431 dst->sin_addr = ip->ip_dst;
432 ifp = ia->ia_ifp;
433 mtu = ifp->if_mtu;
434 ip->ip_ttl = 1;
435 isbroadcast = 1;
436 src = IA_SIN(ia)->sin_addr;
437 } else if (flags & IP_ROUTETOIF) {
438 if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst),
439 M_GETFIB(m)))) == NULL &&
440 (ia = ifatoia(ifa_ifwithnet(sintosa(dst), 0,
441 M_GETFIB(m)))) == NULL) {
442 IPSTAT_INC(ips_noroute);
443 error = ENETUNREACH;
444 goto bad;
445 }
446 ifp = ia->ia_ifp;
447 mtu = ifp->if_mtu;
448 ip->ip_ttl = 1;
449 isbroadcast = ifp->if_flags & IFF_BROADCAST ?
450 in_ifaddr_broadcast(dst->sin_addr, ia) : 0;
451 src = IA_SIN(ia)->sin_addr;
452 } else if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) &&
453 imo != NULL && imo->imo_multicast_ifp != NULL) {
454 /*
455 * Bypass the normal routing lookup for multicast
456 * packets if the interface is specified.
457 */
458 ifp = imo->imo_multicast_ifp;
459 mtu = ifp->if_mtu;
460 IFP_TO_IA(ifp, ia);
461 isbroadcast = 0; /* fool gcc */
462 /* Interface may have no addresses. */
463 if (ia != NULL)
464 src = IA_SIN(ia)->sin_addr;
465 else
466 src.s_addr = INADDR_ANY;
467 } else if (ro != &iproute) {
468 if (ro->ro_nh == NULL) {
469 /*
470 * We want to do any cloning requested by the link
471 * layer, as this is probably required in all cases
472 * for correct operation (as it is for ARP).
473 */
474 uint32_t flowid;
475 flowid = m->m_pkthdr.flowid;
476 ro->ro_nh = fib4_lookup(fibnum, dst->sin_addr, 0,
477 NHR_REF, flowid);
478
479 if (ro->ro_nh == NULL || (!NH_IS_VALID(ro->ro_nh))) {
480 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
481 /*
482 * There is no route for this packet, but it is
483 * possible that a matching SPD entry exists.
484 */
485 no_route_but_check_spd = 1;
486 goto sendit;
487 #endif
488 IPSTAT_INC(ips_noroute);
489 error = EHOSTUNREACH;
490 goto bad;
491 }
492 }
493 struct nhop_object *nh = ro->ro_nh;
494
495 ia = ifatoia(nh->nh_ifa);
496 ifp = nh->nh_ifp;
497 counter_u64_add(nh->nh_pksent, 1);
498 rt_update_ro_flags(ro, nh);
499 if (nh->nh_flags & NHF_GATEWAY)
500 gw = &nh->gw_sa;
501 if (nh->nh_flags & NHF_HOST)
502 isbroadcast = (nh->nh_flags & NHF_BROADCAST);
503 else if ((ifp->if_flags & IFF_BROADCAST) && (gw->sa_family == AF_INET))
504 isbroadcast = in_ifaddr_broadcast(((const struct sockaddr_in *)gw)->sin_addr, ia);
505 else
506 isbroadcast = 0;
507 mtu = nh->nh_mtu;
508 src = IA_SIN(ia)->sin_addr;
509 } else {
510 struct nhop_object *nh;
511
512 nh = fib4_lookup(M_GETFIB(m), dst->sin_addr, 0, NHR_NONE,
513 m->m_pkthdr.flowid);
514 if (nh == NULL) {
515 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
516 /*
517 * There is no route for this packet, but it is
518 * possible that a matching SPD entry exists.
519 */
520 no_route_but_check_spd = 1;
521 goto sendit;
522 #endif
523 IPSTAT_INC(ips_noroute);
524 error = EHOSTUNREACH;
525 goto bad;
526 }
527 ifp = nh->nh_ifp;
528 mtu = nh->nh_mtu;
529 rt_update_ro_flags(ro, nh);
530 if (nh->nh_flags & NHF_GATEWAY)
531 gw = &nh->gw_sa;
532 ia = ifatoia(nh->nh_ifa);
533 src = IA_SIN(ia)->sin_addr;
534 isbroadcast = (((nh->nh_flags & (NHF_HOST | NHF_BROADCAST)) ==
535 (NHF_HOST | NHF_BROADCAST)) ||
536 ((ifp->if_flags & IFF_BROADCAST) &&
537 (gw->sa_family == AF_INET) &&
538 in_ifaddr_broadcast(((const struct sockaddr_in *)gw)->sin_addr, ia)));
539 }
540
541 /* Catch a possible divide by zero later. */
542 KASSERT(mtu > 0, ("%s: mtu %d <= 0, ro=%p (nh_flags=0x%08x) ifp=%p",
543 __func__, mtu, ro,
544 (ro != NULL && ro->ro_nh != NULL) ? ro->ro_nh->nh_flags : 0, ifp));
545
546 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
547 m->m_flags |= M_MCAST;
548 /*
549 * IP destination address is multicast. Make sure "gw"
550 * still points to the address in "ro". (It may have been
551 * changed to point to a gateway address, above.)
552 */
553 gw = (const struct sockaddr *)dst;
554 /*
555 * See if the caller provided any multicast options
556 */
557 if (imo != NULL) {
558 ip->ip_ttl = imo->imo_multicast_ttl;
559 if (imo->imo_multicast_vif != -1)
560 ip->ip_src.s_addr =
561 ip_mcast_src ?
562 ip_mcast_src(imo->imo_multicast_vif) :
563 INADDR_ANY;
564 } else
565 ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
566 /*
567 * Confirm that the outgoing interface supports multicast.
568 */
569 if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
570 if ((ifp->if_flags & IFF_MULTICAST) == 0) {
571 IPSTAT_INC(ips_noroute);
572 error = ENETUNREACH;
573 goto bad;
574 }
575 }
576 /*
577 * If source address not specified yet, use address
578 * of outgoing interface.
579 */
580 if (ip->ip_src.s_addr == INADDR_ANY)
581 ip->ip_src = src;
582
583 if ((imo == NULL && in_mcast_loop) ||
584 (imo && imo->imo_multicast_loop)) {
585 /*
586 * Loop back multicast datagram if not expressly
587 * forbidden to do so, even if we are not a member
588 * of the group; ip_input() will filter it later,
589 * thus deferring a hash lookup and mutex acquisition
590 * at the expense of a cheap copy using m_copym().
591 */
592 ip_mloopback(ifp, m, hlen);
593 } else {
594 /*
595 * If we are acting as a multicast router, perform
596 * multicast forwarding as if the packet had just
597 * arrived on the interface to which we are about
598 * to send. The multicast forwarding function
599 * recursively calls this function, using the
600 * IP_FORWARDING flag to prevent infinite recursion.
601 *
602 * Multicasts that are looped back by ip_mloopback(),
603 * above, will be forwarded by the ip_input() routine,
604 * if necessary.
605 */
606 if (V_ip_mrouter && (flags & IP_FORWARDING) == 0) {
607 /*
608 * If rsvp daemon is not running, do not
609 * set ip_moptions. This ensures that the packet
610 * is multicast and not just sent down one link
611 * as prescribed by rsvpd.
612 */
613 if (!V_rsvp_on)
614 imo = NULL;
615 if (ip_mforward &&
616 ip_mforward(ip, ifp, m, imo) != 0) {
617 m_freem(m);
618 goto done;
619 }
620 }
621 }
622
623 /*
624 * Multicasts with a time-to-live of zero may be looped-
625 * back, above, but must not be transmitted on a network.
626 * Also, multicasts addressed to the loopback interface
627 * are not sent -- the above call to ip_mloopback() will
628 * loop back a copy. ip_input() will drop the copy if
629 * this host does not belong to the destination group on
630 * the loopback interface.
631 */
632 if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
633 m_freem(m);
634 goto done;
635 }
636
637 goto sendit;
638 }
639
640 /*
641 * If the source address is not specified yet, use the address
642 * of the outoing interface.
643 */
644 if (ip->ip_src.s_addr == INADDR_ANY)
645 ip->ip_src = src;
646
647 /*
648 * Look for broadcast address and
649 * verify user is allowed to send
650 * such a packet.
651 */
652 if (isbroadcast) {
653 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
654 error = EADDRNOTAVAIL;
655 goto bad;
656 }
657 if ((flags & IP_ALLOWBROADCAST) == 0) {
658 error = EACCES;
659 goto bad;
660 }
661 /* don't allow broadcast messages to be fragmented */
662 if (ip_len > mtu) {
663 error = EMSGSIZE;
664 goto bad;
665 }
666 m->m_flags |= M_BCAST;
667 } else {
668 m->m_flags &= ~M_BCAST;
669 }
670
671 sendit:
672 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
673 if (IPSEC_ENABLED(ipv4)) {
674 if ((error = IPSEC_OUTPUT(ipv4, m, inp)) != 0) {
675 if (error == EINPROGRESS)
676 error = 0;
677 goto done;
678 }
679 }
680 /*
681 * Check if there was a route for this packet; return error if not.
682 */
683 if (no_route_but_check_spd) {
684 IPSTAT_INC(ips_noroute);
685 error = EHOSTUNREACH;
686 goto bad;
687 }
688 /* Update variables that are affected by ipsec4_output(). */
689 ip = mtod(m, struct ip *);
690 hlen = ip->ip_hl << 2;
691 #endif /* IPSEC */
692
693 /* Jump over all PFIL processing if hooks are not active. */
694 if (PFIL_HOOKED_OUT(V_inet_pfil_head)) {
695 switch (ip_output_pfil(&m, ifp, flags, inp, dst, &fibnum,
696 &error)) {
697 case 1: /* Finished */
698 goto done;
699
700 case 0: /* Continue normally */
701 ip = mtod(m, struct ip *);
702 break;
703
704 case -1: /* Need to try again */
705 /* Reset everything for a new round */
706 if (ro != NULL) {
707 RO_NHFREE(ro);
708 ro->ro_prepend = NULL;
709 }
710 gw = (const struct sockaddr *)dst;
711 ip = mtod(m, struct ip *);
712 goto again;
713 }
714 }
715
716 if (vlan_pcp > -1)
717 EVL_APPLY_PRI(m, vlan_pcp);
718
719 /* IN_LOOPBACK must not appear on the wire - RFC1122. */
720 if (IN_LOOPBACK(ntohl(ip->ip_dst.s_addr)) ||
721 IN_LOOPBACK(ntohl(ip->ip_src.s_addr))) {
722 if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
723 IPSTAT_INC(ips_badaddr);
724 error = EADDRNOTAVAIL;
725 goto bad;
726 }
727 }
728
729 /* Ensure the packet data is mapped if the interface requires it. */
730 if ((ifp->if_capenable & IFCAP_MEXTPG) == 0) {
731 m = mb_unmapped_to_ext(m);
732 if (m == NULL) {
733 IPSTAT_INC(ips_odropped);
734 error = ENOBUFS;
735 goto bad;
736 }
737 }
738
739 m->m_pkthdr.csum_flags |= CSUM_IP;
740 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA & ~ifp->if_hwassist) {
741 in_delayed_cksum(m);
742 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
743 }
744 #if defined(SCTP) || defined(SCTP_SUPPORT)
745 if (m->m_pkthdr.csum_flags & CSUM_SCTP & ~ifp->if_hwassist) {
746 sctp_delayed_cksum(m, (uint32_t)(ip->ip_hl << 2));
747 m->m_pkthdr.csum_flags &= ~CSUM_SCTP;
748 }
749 #endif
750
751 /*
752 * If small enough for interface, or the interface will take
753 * care of the fragmentation for us, we can just send directly.
754 * Note that if_vxlan could have requested TSO even though the outer
755 * frame is UDP. It is correct to not fragment such datagrams and
756 * instead just pass them on to the driver.
757 */
758 if (ip_len <= mtu ||
759 (m->m_pkthdr.csum_flags & ifp->if_hwassist &
760 (CSUM_TSO | CSUM_INNER_TSO)) != 0) {
761 ip->ip_sum = 0;
762 if (m->m_pkthdr.csum_flags & CSUM_IP & ~ifp->if_hwassist) {
763 ip->ip_sum = in_cksum(m, hlen);
764 m->m_pkthdr.csum_flags &= ~CSUM_IP;
765 }
766
767 /*
768 * Record statistics for this interface address.
769 * With CSUM_TSO the byte/packet count will be slightly
770 * incorrect because we count the IP+TCP headers only
771 * once instead of for every generated packet.
772 */
773 if (!(flags & IP_FORWARDING) && ia) {
774 if (m->m_pkthdr.csum_flags &
775 (CSUM_TSO | CSUM_INNER_TSO))
776 counter_u64_add(ia->ia_ifa.ifa_opackets,
777 m->m_pkthdr.len / m->m_pkthdr.tso_segsz);
778 else
779 counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
780
781 counter_u64_add(ia->ia_ifa.ifa_obytes, m->m_pkthdr.len);
782 }
783 #ifdef MBUF_STRESS_TEST
784 if (mbuf_frag_size && m->m_pkthdr.len > mbuf_frag_size)
785 m = m_fragment(m, M_NOWAIT, mbuf_frag_size);
786 #endif
787 /*
788 * Reset layer specific mbuf flags
789 * to avoid confusing lower layers.
790 */
791 m_clrprotoflags(m);
792 IP_PROBE(send, NULL, NULL, ip, ifp, ip, NULL);
793 error = ip_output_send(inp, ifp, m, gw, ro,
794 (flags & IP_NO_SND_TAG_RL) ? false : true);
795 goto done;
796 }
797
798 /* Balk when DF bit is set or the interface didn't support TSO. */
799 if ((ip_off & IP_DF) ||
800 (m->m_pkthdr.csum_flags & (CSUM_TSO | CSUM_INNER_TSO))) {
801 error = EMSGSIZE;
802 IPSTAT_INC(ips_cantfrag);
803 goto bad;
804 }
805
806 /*
807 * Too large for interface; fragment if possible. If successful,
808 * on return, m will point to a list of packets to be sent.
809 */
810 error = ip_fragment(ip, &m, mtu, ifp->if_hwassist);
811 if (error)
812 goto bad;
813 for (; m; m = m0) {
814 m0 = m->m_nextpkt;
815 m->m_nextpkt = 0;
816 if (error == 0) {
817 /* Record statistics for this interface address. */
818 if (ia != NULL) {
819 counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
820 counter_u64_add(ia->ia_ifa.ifa_obytes,
821 m->m_pkthdr.len);
822 }
823 /*
824 * Reset layer specific mbuf flags
825 * to avoid confusing upper layers.
826 */
827 m_clrprotoflags(m);
828
829 IP_PROBE(send, NULL, NULL, mtod(m, struct ip *), ifp,
830 mtod(m, struct ip *), NULL);
831 error = ip_output_send(inp, ifp, m, gw, ro, true);
832 } else
833 m_freem(m);
834 }
835
836 if (error == 0)
837 IPSTAT_INC(ips_fragmented);
838
839 done:
840 return (error);
841 bad:
842 m_freem(m);
843 goto done;
844 }
845
846 /*
847 * Create a chain of fragments which fit the given mtu. m_frag points to the
848 * mbuf to be fragmented; on return it points to the chain with the fragments.
849 * Return 0 if no error. If error, m_frag may contain a partially built
850 * chain of fragments that should be freed by the caller.
851 *
852 * if_hwassist_flags is the hw offload capabilities (see if_data.ifi_hwassist)
853 */
854 int
855 ip_fragment(struct ip *ip, struct mbuf **m_frag, int mtu,
856 u_long if_hwassist_flags)
857 {
858 int error = 0;
859 int hlen = ip->ip_hl << 2;
860 int len = (mtu - hlen) & ~7; /* size of payload in each fragment */
861 int off;
862 struct mbuf *m0 = *m_frag; /* the original packet */
863 int firstlen;
864 struct mbuf **mnext;
865 int nfrags;
866 uint16_t ip_len, ip_off;
867
868 ip_len = ntohs(ip->ip_len);
869 ip_off = ntohs(ip->ip_off);
870
871 /*
872 * Packet shall not have "Don't Fragment" flag and have at least 8
873 * bytes of payload.
874 */
875 if (__predict_false((ip_off & IP_DF) || len < 8)) {
876 IPSTAT_INC(ips_cantfrag);
877 return (EMSGSIZE);
878 }
879
880 /*
881 * If the interface will not calculate checksums on
882 * fragmented packets, then do it here.
883 */
884 if (m0->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
885 in_delayed_cksum(m0);
886 m0->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
887 }
888 #if defined(SCTP) || defined(SCTP_SUPPORT)
889 if (m0->m_pkthdr.csum_flags & CSUM_SCTP) {
890 sctp_delayed_cksum(m0, hlen);
891 m0->m_pkthdr.csum_flags &= ~CSUM_SCTP;
892 }
893 #endif
894 if (len > PAGE_SIZE) {
895 /*
896 * Fragment large datagrams such that each segment
897 * contains a multiple of PAGE_SIZE amount of data,
898 * plus headers. This enables a receiver to perform
899 * page-flipping zero-copy optimizations.
900 *
901 * XXX When does this help given that sender and receiver
902 * could have different page sizes, and also mtu could
903 * be less than the receiver's page size ?
904 */
905 int newlen;
906
907 off = MIN(mtu, m0->m_pkthdr.len);
908
909 /*
910 * firstlen (off - hlen) must be aligned on an
911 * 8-byte boundary
912 */
913 if (off < hlen)
914 goto smart_frag_failure;
915 off = ((off - hlen) & ~7) + hlen;
916 newlen = (~PAGE_MASK) & mtu;
917 if ((newlen + sizeof (struct ip)) > mtu) {
918 /* we failed, go back the default */
919 smart_frag_failure:
920 newlen = len;
921 off = hlen + len;
922 }
923 len = newlen;
924
925 } else {
926 off = hlen + len;
927 }
928
929 firstlen = off - hlen;
930 mnext = &m0->m_nextpkt; /* pointer to next packet */
931
932 /*
933 * Loop through length of segment after first fragment,
934 * make new header and copy data of each part and link onto chain.
935 * Here, m0 is the original packet, m is the fragment being created.
936 * The fragments are linked off the m_nextpkt of the original
937 * packet, which after processing serves as the first fragment.
938 */
939 for (nfrags = 1; off < ip_len; off += len, nfrags++) {
940 struct ip *mhip; /* ip header on the fragment */
941 struct mbuf *m;
942 int mhlen = sizeof (struct ip);
943
944 m = m_gethdr(M_NOWAIT, MT_DATA);
945 if (m == NULL) {
946 error = ENOBUFS;
947 IPSTAT_INC(ips_odropped);
948 goto done;
949 }
950 /*
951 * Make sure the complete packet header gets copied
952 * from the originating mbuf to the newly created
953 * mbuf. This also ensures that existing firewall
954 * classification(s), VLAN tags and so on get copied
955 * to the resulting fragmented packet(s):
956 */
957 if (m_dup_pkthdr(m, m0, M_NOWAIT) == 0) {
958 m_free(m);
959 error = ENOBUFS;
960 IPSTAT_INC(ips_odropped);
961 goto done;
962 }
963 /*
964 * In the first mbuf, leave room for the link header, then
965 * copy the original IP header including options. The payload
966 * goes into an additional mbuf chain returned by m_copym().
967 */
968 m->m_data += max_linkhdr;
969 mhip = mtod(m, struct ip *);
970 *mhip = *ip;
971 if (hlen > sizeof (struct ip)) {
972 mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
973 mhip->ip_v = IPVERSION;
974 mhip->ip_hl = mhlen >> 2;
975 }
976 m->m_len = mhlen;
977 /* XXX do we need to add ip_off below ? */
978 mhip->ip_off = ((off - hlen) >> 3) + ip_off;
979 if (off + len >= ip_len)
980 len = ip_len - off;
981 else
982 mhip->ip_off |= IP_MF;
983 mhip->ip_len = htons((u_short)(len + mhlen));
984 m->m_next = m_copym(m0, off, len, M_NOWAIT);
985 if (m->m_next == NULL) { /* copy failed */
986 m_free(m);
987 error = ENOBUFS; /* ??? */
988 IPSTAT_INC(ips_odropped);
989 goto done;
990 }
991 m->m_pkthdr.len = mhlen + len;
992 #ifdef MAC
993 mac_netinet_fragment(m0, m);
994 #endif
995 mhip->ip_off = htons(mhip->ip_off);
996 mhip->ip_sum = 0;
997 if (m->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
998 mhip->ip_sum = in_cksum(m, mhlen);
999 m->m_pkthdr.csum_flags &= ~CSUM_IP;
1000 }
1001 *mnext = m;
1002 mnext = &m->m_nextpkt;
1003 }
1004 IPSTAT_ADD(ips_ofragments, nfrags);
1005
1006 /*
1007 * Update first fragment by trimming what's been copied out
1008 * and updating header.
1009 */
1010 m_adj(m0, hlen + firstlen - ip_len);
1011 m0->m_pkthdr.len = hlen + firstlen;
1012 ip->ip_len = htons((u_short)m0->m_pkthdr.len);
1013 ip->ip_off = htons(ip_off | IP_MF);
1014 ip->ip_sum = 0;
1015 if (m0->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
1016 ip->ip_sum = in_cksum(m0, hlen);
1017 m0->m_pkthdr.csum_flags &= ~CSUM_IP;
1018 }
1019
1020 done:
1021 *m_frag = m0;
1022 return error;
1023 }
1024
1025 void
1026 in_delayed_cksum(struct mbuf *m)
1027 {
1028 struct ip *ip;
1029 struct udphdr *uh;
1030 uint16_t cklen, csum, offset;
1031
1032 ip = mtod(m, struct ip *);
1033 offset = ip->ip_hl << 2 ;
1034
1035 if (m->m_pkthdr.csum_flags & CSUM_UDP) {
1036 /* if udp header is not in the first mbuf copy udplen */
1037 if (offset + sizeof(struct udphdr) > m->m_len) {
1038 m_copydata(m, offset + offsetof(struct udphdr,
1039 uh_ulen), sizeof(cklen), (caddr_t)&cklen);
1040 cklen = ntohs(cklen);
1041 } else {
1042 uh = (struct udphdr *)mtodo(m, offset);
1043 cklen = ntohs(uh->uh_ulen);
1044 }
1045 csum = in_cksum_skip(m, cklen + offset, offset);
1046 if (csum == 0)
1047 csum = 0xffff;
1048 } else {
1049 cklen = ntohs(ip->ip_len);
1050 csum = in_cksum_skip(m, cklen, offset);
1051 }
1052 offset += m->m_pkthdr.csum_data; /* checksum offset */
1053
1054 if (offset + sizeof(csum) > m->m_len)
1055 m_copyback(m, offset, sizeof(csum), (caddr_t)&csum);
1056 else
1057 *(u_short *)mtodo(m, offset) = csum;
1058 }
1059
1060 /*
1061 * IP socket option processing.
1062 */
1063 int
1064 ip_ctloutput(struct socket *so, struct sockopt *sopt)
1065 {
1066 struct inpcb *inp = sotoinpcb(so);
1067 int error, optval;
1068 #ifdef RSS
1069 uint32_t rss_bucket;
1070 int retval;
1071 #endif
1072
1073 error = optval = 0;
1074 if (sopt->sopt_level != IPPROTO_IP) {
1075 error = EINVAL;
1076
1077 if (sopt->sopt_level == SOL_SOCKET &&
1078 sopt->sopt_dir == SOPT_SET) {
1079 switch (sopt->sopt_name) {
1080 case SO_REUSEADDR:
1081 INP_WLOCK(inp);
1082 if ((so->so_options & SO_REUSEADDR) != 0)
1083 inp->inp_flags2 |= INP_REUSEADDR;
1084 else
1085 inp->inp_flags2 &= ~INP_REUSEADDR;
1086 INP_WUNLOCK(inp);
1087 error = 0;
1088 break;
1089 case SO_REUSEPORT:
1090 INP_WLOCK(inp);
1091 if ((so->so_options & SO_REUSEPORT) != 0)
1092 inp->inp_flags2 |= INP_REUSEPORT;
1093 else
1094 inp->inp_flags2 &= ~INP_REUSEPORT;
1095 INP_WUNLOCK(inp);
1096 error = 0;
1097 break;
1098 case SO_REUSEPORT_LB:
1099 INP_WLOCK(inp);
1100 if ((so->so_options & SO_REUSEPORT_LB) != 0)
1101 inp->inp_flags2 |= INP_REUSEPORT_LB;
1102 else
1103 inp->inp_flags2 &= ~INP_REUSEPORT_LB;
1104 INP_WUNLOCK(inp);
1105 error = 0;
1106 break;
1107 case SO_SETFIB:
1108 INP_WLOCK(inp);
1109 inp->inp_inc.inc_fibnum = so->so_fibnum;
1110 INP_WUNLOCK(inp);
1111 error = 0;
1112 break;
1113 case SO_MAX_PACING_RATE:
1114 #ifdef RATELIMIT
1115 INP_WLOCK(inp);
1116 inp->inp_flags2 |= INP_RATE_LIMIT_CHANGED;
1117 INP_WUNLOCK(inp);
1118 error = 0;
1119 #else
1120 error = EOPNOTSUPP;
1121 #endif
1122 break;
1123 default:
1124 break;
1125 }
1126 }
1127 return (error);
1128 }
1129
1130 switch (sopt->sopt_dir) {
1131 case SOPT_SET:
1132 switch (sopt->sopt_name) {
1133 case IP_OPTIONS:
1134 #ifdef notyet
1135 case IP_RETOPTS:
1136 #endif
1137 {
1138 struct mbuf *m;
1139 if (sopt->sopt_valsize > MLEN) {
1140 error = EMSGSIZE;
1141 break;
1142 }
1143 m = m_get(sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
1144 if (m == NULL) {
1145 error = ENOBUFS;
1146 break;
1147 }
1148 m->m_len = sopt->sopt_valsize;
1149 error = sooptcopyin(sopt, mtod(m, char *), m->m_len,
1150 m->m_len);
1151 if (error) {
1152 m_free(m);
1153 break;
1154 }
1155 INP_WLOCK(inp);
1156 error = ip_pcbopts(inp, sopt->sopt_name, m);
1157 INP_WUNLOCK(inp);
1158 return (error);
1159 }
1160
1161 case IP_BINDANY:
1162 if (sopt->sopt_td != NULL) {
1163 error = priv_check(sopt->sopt_td,
1164 PRIV_NETINET_BINDANY);
1165 if (error)
1166 break;
1167 }
1168 /* FALLTHROUGH */
1169 case IP_BINDMULTI:
1170 #ifdef RSS
1171 case IP_RSS_LISTEN_BUCKET:
1172 #endif
1173 case IP_TOS:
1174 case IP_TTL:
1175 case IP_MINTTL:
1176 case IP_RECVOPTS:
1177 case IP_RECVRETOPTS:
1178 case IP_ORIGDSTADDR:
1179 case IP_RECVDSTADDR:
1180 case IP_RECVTTL:
1181 case IP_RECVIF:
1182 case IP_ONESBCAST:
1183 case IP_DONTFRAG:
1184 case IP_RECVTOS:
1185 case IP_RECVFLOWID:
1186 #ifdef RSS
1187 case IP_RECVRSSBUCKETID:
1188 #endif
1189 case IP_VLAN_PCP:
1190 error = sooptcopyin(sopt, &optval, sizeof optval,
1191 sizeof optval);
1192 if (error)
1193 break;
1194
1195 switch (sopt->sopt_name) {
1196 case IP_TOS:
1197 inp->inp_ip_tos = optval;
1198 break;
1199
1200 case IP_TTL:
1201 inp->inp_ip_ttl = optval;
1202 break;
1203
1204 case IP_MINTTL:
1205 if (optval >= 0 && optval <= MAXTTL)
1206 inp->inp_ip_minttl = optval;
1207 else
1208 error = EINVAL;
1209 break;
1210
1211 #define OPTSET(bit) do { \
1212 INP_WLOCK(inp); \
1213 if (optval) \
1214 inp->inp_flags |= bit; \
1215 else \
1216 inp->inp_flags &= ~bit; \
1217 INP_WUNLOCK(inp); \
1218 } while (0)
1219
1220 #define OPTSET2(bit, val) do { \
1221 INP_WLOCK(inp); \
1222 if (val) \
1223 inp->inp_flags2 |= bit; \
1224 else \
1225 inp->inp_flags2 &= ~bit; \
1226 INP_WUNLOCK(inp); \
1227 } while (0)
1228
1229 case IP_RECVOPTS:
1230 OPTSET(INP_RECVOPTS);
1231 break;
1232
1233 case IP_RECVRETOPTS:
1234 OPTSET(INP_RECVRETOPTS);
1235 break;
1236
1237 case IP_RECVDSTADDR:
1238 OPTSET(INP_RECVDSTADDR);
1239 break;
1240
1241 case IP_ORIGDSTADDR:
1242 OPTSET2(INP_ORIGDSTADDR, optval);
1243 break;
1244
1245 case IP_RECVTTL:
1246 OPTSET(INP_RECVTTL);
1247 break;
1248
1249 case IP_RECVIF:
1250 OPTSET(INP_RECVIF);
1251 break;
1252
1253 case IP_ONESBCAST:
1254 OPTSET(INP_ONESBCAST);
1255 break;
1256 case IP_DONTFRAG:
1257 OPTSET(INP_DONTFRAG);
1258 break;
1259 case IP_BINDANY:
1260 OPTSET(INP_BINDANY);
1261 break;
1262 case IP_RECVTOS:
1263 OPTSET(INP_RECVTOS);
1264 break;
1265 case IP_BINDMULTI:
1266 OPTSET2(INP_BINDMULTI, optval);
1267 break;
1268 case IP_RECVFLOWID:
1269 OPTSET2(INP_RECVFLOWID, optval);
1270 break;
1271 #ifdef RSS
1272 case IP_RSS_LISTEN_BUCKET:
1273 if ((optval >= 0) &&
1274 (optval < rss_getnumbuckets())) {
1275 inp->inp_rss_listen_bucket = optval;
1276 OPTSET2(INP_RSS_BUCKET_SET, 1);
1277 } else {
1278 error = EINVAL;
1279 }
1280 break;
1281 case IP_RECVRSSBUCKETID:
1282 OPTSET2(INP_RECVRSSBUCKETID, optval);
1283 break;
1284 #endif
1285 case IP_VLAN_PCP:
1286 if ((optval >= -1) && (optval <=
1287 (INP_2PCP_MASK >> INP_2PCP_SHIFT))) {
1288 if (optval == -1) {
1289 INP_WLOCK(inp);
1290 inp->inp_flags2 &=
1291 ~(INP_2PCP_SET |
1292 INP_2PCP_MASK);
1293 INP_WUNLOCK(inp);
1294 } else {
1295 INP_WLOCK(inp);
1296 inp->inp_flags2 |=
1297 INP_2PCP_SET;
1298 inp->inp_flags2 &=
1299 ~INP_2PCP_MASK;
1300 inp->inp_flags2 |=
1301 optval << INP_2PCP_SHIFT;
1302 INP_WUNLOCK(inp);
1303 }
1304 } else
1305 error = EINVAL;
1306 break;
1307 }
1308 break;
1309 #undef OPTSET
1310 #undef OPTSET2
1311
1312 /*
1313 * Multicast socket options are processed by the in_mcast
1314 * module.
1315 */
1316 case IP_MULTICAST_IF:
1317 case IP_MULTICAST_VIF:
1318 case IP_MULTICAST_TTL:
1319 case IP_MULTICAST_LOOP:
1320 case IP_ADD_MEMBERSHIP:
1321 case IP_DROP_MEMBERSHIP:
1322 case IP_ADD_SOURCE_MEMBERSHIP:
1323 case IP_DROP_SOURCE_MEMBERSHIP:
1324 case IP_BLOCK_SOURCE:
1325 case IP_UNBLOCK_SOURCE:
1326 case IP_MSFILTER:
1327 case MCAST_JOIN_GROUP:
1328 case MCAST_LEAVE_GROUP:
1329 case MCAST_JOIN_SOURCE_GROUP:
1330 case MCAST_LEAVE_SOURCE_GROUP:
1331 case MCAST_BLOCK_SOURCE:
1332 case MCAST_UNBLOCK_SOURCE:
1333 error = inp_setmoptions(inp, sopt);
1334 break;
1335
1336 case IP_PORTRANGE:
1337 error = sooptcopyin(sopt, &optval, sizeof optval,
1338 sizeof optval);
1339 if (error)
1340 break;
1341
1342 INP_WLOCK(inp);
1343 switch (optval) {
1344 case IP_PORTRANGE_DEFAULT:
1345 inp->inp_flags &= ~(INP_LOWPORT);
1346 inp->inp_flags &= ~(INP_HIGHPORT);
1347 break;
1348
1349 case IP_PORTRANGE_HIGH:
1350 inp->inp_flags &= ~(INP_LOWPORT);
1351 inp->inp_flags |= INP_HIGHPORT;
1352 break;
1353
1354 case IP_PORTRANGE_LOW:
1355 inp->inp_flags &= ~(INP_HIGHPORT);
1356 inp->inp_flags |= INP_LOWPORT;
1357 break;
1358
1359 default:
1360 error = EINVAL;
1361 break;
1362 }
1363 INP_WUNLOCK(inp);
1364 break;
1365
1366 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
1367 case IP_IPSEC_POLICY:
1368 if (IPSEC_ENABLED(ipv4)) {
1369 error = IPSEC_PCBCTL(ipv4, inp, sopt);
1370 break;
1371 }
1372 /* FALLTHROUGH */
1373 #endif /* IPSEC */
1374
1375 default:
1376 error = ENOPROTOOPT;
1377 break;
1378 }
1379 break;
1380
1381 case SOPT_GET:
1382 switch (sopt->sopt_name) {
1383 case IP_OPTIONS:
1384 case IP_RETOPTS:
1385 INP_RLOCK(inp);
1386 if (inp->inp_options) {
1387 struct mbuf *options;
1388
1389 options = m_copym(inp->inp_options, 0,
1390 M_COPYALL, M_NOWAIT);
1391 INP_RUNLOCK(inp);
1392 if (options != NULL) {
1393 error = sooptcopyout(sopt,
1394 mtod(options, char *),
1395 options->m_len);
1396 m_freem(options);
1397 } else
1398 error = ENOMEM;
1399 } else {
1400 INP_RUNLOCK(inp);
1401 sopt->sopt_valsize = 0;
1402 }
1403 break;
1404
1405 case IP_TOS:
1406 case IP_TTL:
1407 case IP_MINTTL:
1408 case IP_RECVOPTS:
1409 case IP_RECVRETOPTS:
1410 case IP_ORIGDSTADDR:
1411 case IP_RECVDSTADDR:
1412 case IP_RECVTTL:
1413 case IP_RECVIF:
1414 case IP_PORTRANGE:
1415 case IP_ONESBCAST:
1416 case IP_DONTFRAG:
1417 case IP_BINDANY:
1418 case IP_RECVTOS:
1419 case IP_BINDMULTI:
1420 case IP_FLOWID:
1421 case IP_FLOWTYPE:
1422 case IP_RECVFLOWID:
1423 #ifdef RSS
1424 case IP_RSSBUCKETID:
1425 case IP_RECVRSSBUCKETID:
1426 #endif
1427 case IP_VLAN_PCP:
1428 switch (sopt->sopt_name) {
1429 case IP_TOS:
1430 optval = inp->inp_ip_tos;
1431 break;
1432
1433 case IP_TTL:
1434 optval = inp->inp_ip_ttl;
1435 break;
1436
1437 case IP_MINTTL:
1438 optval = inp->inp_ip_minttl;
1439 break;
1440
1441 #define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
1442 #define OPTBIT2(bit) (inp->inp_flags2 & bit ? 1 : 0)
1443
1444 case IP_RECVOPTS:
1445 optval = OPTBIT(INP_RECVOPTS);
1446 break;
1447
1448 case IP_RECVRETOPTS:
1449 optval = OPTBIT(INP_RECVRETOPTS);
1450 break;
1451
1452 case IP_RECVDSTADDR:
1453 optval = OPTBIT(INP_RECVDSTADDR);
1454 break;
1455
1456 case IP_ORIGDSTADDR:
1457 optval = OPTBIT2(INP_ORIGDSTADDR);
1458 break;
1459
1460 case IP_RECVTTL:
1461 optval = OPTBIT(INP_RECVTTL);
1462 break;
1463
1464 case IP_RECVIF:
1465 optval = OPTBIT(INP_RECVIF);
1466 break;
1467
1468 case IP_PORTRANGE:
1469 if (inp->inp_flags & INP_HIGHPORT)
1470 optval = IP_PORTRANGE_HIGH;
1471 else if (inp->inp_flags & INP_LOWPORT)
1472 optval = IP_PORTRANGE_LOW;
1473 else
1474 optval = 0;
1475 break;
1476
1477 case IP_ONESBCAST:
1478 optval = OPTBIT(INP_ONESBCAST);
1479 break;
1480 case IP_DONTFRAG:
1481 optval = OPTBIT(INP_DONTFRAG);
1482 break;
1483 case IP_BINDANY:
1484 optval = OPTBIT(INP_BINDANY);
1485 break;
1486 case IP_RECVTOS:
1487 optval = OPTBIT(INP_RECVTOS);
1488 break;
1489 case IP_FLOWID:
1490 optval = inp->inp_flowid;
1491 break;
1492 case IP_FLOWTYPE:
1493 optval = inp->inp_flowtype;
1494 break;
1495 case IP_RECVFLOWID:
1496 optval = OPTBIT2(INP_RECVFLOWID);
1497 break;
1498 #ifdef RSS
1499 case IP_RSSBUCKETID:
1500 retval = rss_hash2bucket(inp->inp_flowid,
1501 inp->inp_flowtype,
1502 &rss_bucket);
1503 if (retval == 0)
1504 optval = rss_bucket;
1505 else
1506 error = EINVAL;
1507 break;
1508 case IP_RECVRSSBUCKETID:
1509 optval = OPTBIT2(INP_RECVRSSBUCKETID);
1510 break;
1511 #endif
1512 case IP_BINDMULTI:
1513 optval = OPTBIT2(INP_BINDMULTI);
1514 break;
1515 case IP_VLAN_PCP:
1516 if (OPTBIT2(INP_2PCP_SET)) {
1517 optval = (inp->inp_flags2 &
1518 INP_2PCP_MASK) >> INP_2PCP_SHIFT;
1519 } else {
1520 optval = -1;
1521 }
1522 break;
1523 }
1524 error = sooptcopyout(sopt, &optval, sizeof optval);
1525 break;
1526
1527 /*
1528 * Multicast socket options are processed by the in_mcast
1529 * module.
1530 */
1531 case IP_MULTICAST_IF:
1532 case IP_MULTICAST_VIF:
1533 case IP_MULTICAST_TTL:
1534 case IP_MULTICAST_LOOP:
1535 case IP_MSFILTER:
1536 error = inp_getmoptions(inp, sopt);
1537 break;
1538
1539 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
1540 case IP_IPSEC_POLICY:
1541 if (IPSEC_ENABLED(ipv4)) {
1542 error = IPSEC_PCBCTL(ipv4, inp, sopt);
1543 break;
1544 }
1545 /* FALLTHROUGH */
1546 #endif /* IPSEC */
1547
1548 default:
1549 error = ENOPROTOOPT;
1550 break;
1551 }
1552 break;
1553 }
1554 return (error);
1555 }
1556
1557 /*
1558 * Routine called from ip_output() to loop back a copy of an IP multicast
1559 * packet to the input queue of a specified interface. Note that this
1560 * calls the output routine of the loopback "driver", but with an interface
1561 * pointer that might NOT be a loopback interface -- evil, but easier than
1562 * replicating that code here.
1563 */
1564 static void
1565 ip_mloopback(struct ifnet *ifp, const struct mbuf *m, int hlen)
1566 {
1567 struct ip *ip;
1568 struct mbuf *copym;
1569
1570 /*
1571 * Make a deep copy of the packet because we're going to
1572 * modify the pack in order to generate checksums.
1573 */
1574 copym = m_dup(m, M_NOWAIT);
1575 if (copym != NULL && (!M_WRITABLE(copym) || copym->m_len < hlen))
1576 copym = m_pullup(copym, hlen);
1577 if (copym != NULL) {
1578 /* If needed, compute the checksum and mark it as valid. */
1579 if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
1580 in_delayed_cksum(copym);
1581 copym->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
1582 copym->m_pkthdr.csum_flags |=
1583 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1584 copym->m_pkthdr.csum_data = 0xffff;
1585 }
1586 /*
1587 * We don't bother to fragment if the IP length is greater
1588 * than the interface's MTU. Can this possibly matter?
1589 */
1590 ip = mtod(copym, struct ip *);
1591 ip->ip_sum = 0;
1592 ip->ip_sum = in_cksum(copym, hlen);
1593 if_simloop(ifp, copym, AF_INET, 0);
1594 }
1595 }
Cache object: ddf264fbd58a2c01bd54463606f7782b
|