34
35#include "opt_inet.h"
36#include "opt_ipfw.h"
37#include "opt_ipsec.h"
38#include "opt_mbuf_stress_test.h"
39#include "opt_mpath.h"
40#include "opt_route.h"
41#include "opt_sctp.h"
42
43#include <sys/param.h>
44#include <sys/systm.h>
45#include <sys/kernel.h>
46#include <sys/malloc.h>
47#include <sys/mbuf.h>
48#include <sys/priv.h>
49#include <sys/proc.h>
50#include <sys/protosw.h>
51#include <sys/sdt.h>
52#include <sys/socket.h>
53#include <sys/socketvar.h>
54#include <sys/sysctl.h>
55#include <sys/ucred.h>
56
57#include <net/if.h>
58#include <net/if_var.h>
59#include <net/if_llatbl.h>
60#include <net/netisr.h>
61#include <net/pfil.h>
62#include <net/route.h>
63#include <net/flowtable.h>
64#ifdef RADIX_MPATH
65#include <net/radix_mpath.h>
66#endif
67#include <net/vnet.h>
68
69#include <netinet/in.h>
70#include <netinet/in_kdtrace.h>
71#include <netinet/in_systm.h>
72#include <netinet/ip.h>
73#include <netinet/in_pcb.h>
74#include <netinet/in_var.h>
75#include <netinet/ip_var.h>
76#include <netinet/ip_options.h>
77#ifdef SCTP
78#include <netinet/sctp.h>
79#include <netinet/sctp_crc32.h>
80#endif
81
82#ifdef IPSEC
83#include <netinet/ip_ipsec.h>
84#include <netipsec/ipsec.h>
85#endif /* IPSEC*/
86
87#include <machine/in_cksum.h>
88
89#include <security/mac/mac_framework.h>
90
91VNET_DEFINE(u_short, ip_id);
92
93#ifdef MBUF_STRESS_TEST
94static int mbuf_frag_size = 0;
95SYSCTL_INT(_net_inet_ip, OID_AUTO, mbuf_frag_size, CTLFLAG_RW,
96 &mbuf_frag_size, 0, "Fragment outgoing mbufs to this size");
97#endif
98
99static void ip_mloopback
100 (struct ifnet *, struct mbuf *, struct sockaddr_in *, int);
101
102
103extern int in_mcast_loop;
104extern struct protosw inetsw[];
105
106/*
107 * IP output. The packet in mbuf chain m contains a skeletal IP
108 * header (with len, off, ttl, proto, tos, src, dst).
109 * The mbuf chain containing the packet will be freed.
110 * The mbuf opt, if present, will not be freed.
111 * If route ro is present and has ro_rt initialized, route lookup would be
112 * skipped and ro->ro_rt would be used. If ro is present but ro->ro_rt is NULL,
113 * then result of route lookup is stored in ro->ro_rt.
114 *
115 * In the IP forwarding case, the packet will arrive with options already
116 * inserted, so must have a NULL opt pointer.
117 */
118int
119ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags,
120 struct ip_moptions *imo, struct inpcb *inp)
121{
122 struct ip *ip;
123 struct ifnet *ifp = NULL; /* keep compiler happy */
124 struct mbuf *m0;
125 int hlen = sizeof (struct ip);
126 int mtu;
127 int error = 0;
128 struct sockaddr_in *dst;
129 const struct sockaddr_in *gw;
130 struct in_ifaddr *ia;
131 int isbroadcast;
132 uint16_t ip_len, ip_off;
133 struct route iproute;
134 struct rtentry *rte; /* cache for ro->ro_rt */
135 struct in_addr odst;
136 struct m_tag *fwd_tag = NULL;
137#ifdef IPSEC
138 int no_route_but_check_spd = 0;
139#endif
140 M_ASSERTPKTHDR(m);
141
142 if (inp != NULL) {
143 INP_LOCK_ASSERT(inp);
144 M_SETFIB(m, inp->inp_inc.inc_fibnum);
145 if (inp->inp_flags & (INP_HW_FLOWID|INP_SW_FLOWID)) {
146 m->m_pkthdr.flowid = inp->inp_flowid;
147 m->m_flags |= M_FLOWID;
148 }
149 }
150
151 if (ro == NULL) {
152 ro = &iproute;
153 bzero(ro, sizeof (*ro));
154 }
155
156#ifdef FLOWTABLE
157 if (ro->ro_rt == NULL)
158 (void )flowtable_lookup(AF_INET, m, ro);
159#endif
160
161 if (opt) {
162 int len = 0;
163 m = ip_insertoptions(m, opt, &len);
164 if (len != 0)
165 hlen = len; /* ip->ip_hl is updated above */
166 }
167 ip = mtod(m, struct ip *);
168 ip_len = ntohs(ip->ip_len);
169 ip_off = ntohs(ip->ip_off);
170
171 /*
172 * Fill in IP header. If we are not allowing fragmentation,
173 * then the ip_id field is meaningless, but we don't set it
174 * to zero. Doing so causes various problems when devices along
175 * the path (routers, load balancers, firewalls, etc.) illegally
176 * disable DF on our packet. Note that a 16-bit counter
177 * will wrap around in less than 10 seconds at 100 Mbit/s on a
178 * medium with MTU 1500. See Steven M. Bellovin, "A Technique
179 * for Counting NATted Hosts", Proc. IMW'02, available at
180 * <http://www.cs.columbia.edu/~smb/papers/fnat.pdf>.
181 */
182 if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
183 ip->ip_v = IPVERSION;
184 ip->ip_hl = hlen >> 2;
185 ip->ip_id = ip_newid();
186 IPSTAT_INC(ips_localout);
187 } else {
188 /* Header already set, fetch hlen from there */
189 hlen = ip->ip_hl << 2;
190 }
191
192 /*
193 * dst/gw handling:
194 *
195 * dst can be rewritten but always points to &ro->ro_dst.
196 * gw is readonly but can point either to dst OR rt_gateway,
197 * therefore we need restore gw if we're redoing lookup.
198 */
199 gw = dst = (struct sockaddr_in *)&ro->ro_dst;
200again:
201 ia = NULL;
202 /*
203 * If there is a cached route, check that it is to the same
204 * destination and is still up. If not, free it and try again.
205 * The address family should also be checked in case of sharing
206 * the cache with IPv6.
207 */
208 rte = ro->ro_rt;
209 if (rte && ((rte->rt_flags & RTF_UP) == 0 ||
210 rte->rt_ifp == NULL ||
211 !RT_LINK_IS_UP(rte->rt_ifp) ||
212 dst->sin_family != AF_INET ||
213 dst->sin_addr.s_addr != ip->ip_dst.s_addr)) {
214 RO_RTFREE(ro);
215 ro->ro_lle = NULL;
216 rte = NULL;
217 gw = dst;
218 }
219 if (rte == NULL && fwd_tag == NULL) {
220 bzero(dst, sizeof(*dst));
221 dst->sin_family = AF_INET;
222 dst->sin_len = sizeof(*dst);
223 dst->sin_addr = ip->ip_dst;
224 }
225 /*
226 * If routing to interface only, short circuit routing lookup.
227 * The use of an all-ones broadcast address implies this; an
228 * interface is specified by the broadcast address of an interface,
229 * or the destination address of a ptp interface.
230 */
231 if (flags & IP_SENDONES) {
232 if ((ia = ifatoia(ifa_ifwithbroadaddr(sintosa(dst)))) == NULL &&
233 (ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL) {
234 IPSTAT_INC(ips_noroute);
235 error = ENETUNREACH;
236 goto bad;
237 }
238 ip->ip_dst.s_addr = INADDR_BROADCAST;
239 dst->sin_addr = ip->ip_dst;
240 ifp = ia->ia_ifp;
241 ip->ip_ttl = 1;
242 isbroadcast = 1;
243 } else if (flags & IP_ROUTETOIF) {
244 if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL &&
245 (ia = ifatoia(ifa_ifwithnet(sintosa(dst), 0))) == NULL) {
246 IPSTAT_INC(ips_noroute);
247 error = ENETUNREACH;
248 goto bad;
249 }
250 ifp = ia->ia_ifp;
251 ip->ip_ttl = 1;
252 isbroadcast = in_broadcast(dst->sin_addr, ifp);
253 } else if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) &&
254 imo != NULL && imo->imo_multicast_ifp != NULL) {
255 /*
256 * Bypass the normal routing lookup for multicast
257 * packets if the interface is specified.
258 */
259 ifp = imo->imo_multicast_ifp;
260 IFP_TO_IA(ifp, ia);
261 isbroadcast = 0; /* fool gcc */
262 } else {
263 /*
264 * We want to do any cloning requested by the link layer,
265 * as this is probably required in all cases for correct
266 * operation (as it is for ARP).
267 */
268 if (rte == NULL) {
269#ifdef RADIX_MPATH
270 rtalloc_mpath_fib(ro,
271 ntohl(ip->ip_src.s_addr ^ ip->ip_dst.s_addr),
272 inp ? inp->inp_inc.inc_fibnum : M_GETFIB(m));
273#else
274 in_rtalloc_ign(ro, 0,
275 inp ? inp->inp_inc.inc_fibnum : M_GETFIB(m));
276#endif
277 rte = ro->ro_rt;
278 }
279 if (rte == NULL ||
280 rte->rt_ifp == NULL ||
281 !RT_LINK_IS_UP(rte->rt_ifp)) {
282#ifdef IPSEC
283 /*
284 * There is no route for this packet, but it is
285 * possible that a matching SPD entry exists.
286 */
287 no_route_but_check_spd = 1;
288 mtu = 0; /* Silence GCC warning. */
289 goto sendit;
290#endif
291 IPSTAT_INC(ips_noroute);
292 error = EHOSTUNREACH;
293 goto bad;
294 }
295 ia = ifatoia(rte->rt_ifa);
296 ifp = rte->rt_ifp;
| 34
35#include "opt_inet.h"
36#include "opt_ipfw.h"
37#include "opt_ipsec.h"
38#include "opt_mbuf_stress_test.h"
39#include "opt_mpath.h"
40#include "opt_route.h"
41#include "opt_sctp.h"
42
43#include <sys/param.h>
44#include <sys/systm.h>
45#include <sys/kernel.h>
46#include <sys/malloc.h>
47#include <sys/mbuf.h>
48#include <sys/priv.h>
49#include <sys/proc.h>
50#include <sys/protosw.h>
51#include <sys/sdt.h>
52#include <sys/socket.h>
53#include <sys/socketvar.h>
54#include <sys/sysctl.h>
55#include <sys/ucred.h>
56
57#include <net/if.h>
58#include <net/if_var.h>
59#include <net/if_llatbl.h>
60#include <net/netisr.h>
61#include <net/pfil.h>
62#include <net/route.h>
63#include <net/flowtable.h>
64#ifdef RADIX_MPATH
65#include <net/radix_mpath.h>
66#endif
67#include <net/vnet.h>
68
69#include <netinet/in.h>
70#include <netinet/in_kdtrace.h>
71#include <netinet/in_systm.h>
72#include <netinet/ip.h>
73#include <netinet/in_pcb.h>
74#include <netinet/in_var.h>
75#include <netinet/ip_var.h>
76#include <netinet/ip_options.h>
77#ifdef SCTP
78#include <netinet/sctp.h>
79#include <netinet/sctp_crc32.h>
80#endif
81
82#ifdef IPSEC
83#include <netinet/ip_ipsec.h>
84#include <netipsec/ipsec.h>
85#endif /* IPSEC*/
86
87#include <machine/in_cksum.h>
88
89#include <security/mac/mac_framework.h>
90
91VNET_DEFINE(u_short, ip_id);
92
93#ifdef MBUF_STRESS_TEST
94static int mbuf_frag_size = 0;
95SYSCTL_INT(_net_inet_ip, OID_AUTO, mbuf_frag_size, CTLFLAG_RW,
96 &mbuf_frag_size, 0, "Fragment outgoing mbufs to this size");
97#endif
98
99static void ip_mloopback
100 (struct ifnet *, struct mbuf *, struct sockaddr_in *, int);
101
102
103extern int in_mcast_loop;
104extern struct protosw inetsw[];
105
106/*
107 * IP output. The packet in mbuf chain m contains a skeletal IP
108 * header (with len, off, ttl, proto, tos, src, dst).
109 * The mbuf chain containing the packet will be freed.
110 * The mbuf opt, if present, will not be freed.
111 * If route ro is present and has ro_rt initialized, route lookup would be
112 * skipped and ro->ro_rt would be used. If ro is present but ro->ro_rt is NULL,
113 * then result of route lookup is stored in ro->ro_rt.
114 *
115 * In the IP forwarding case, the packet will arrive with options already
116 * inserted, so must have a NULL opt pointer.
117 */
118int
119ip_output(struct mbuf *m, struct mbuf *opt, struct route *ro, int flags,
120 struct ip_moptions *imo, struct inpcb *inp)
121{
122 struct ip *ip;
123 struct ifnet *ifp = NULL; /* keep compiler happy */
124 struct mbuf *m0;
125 int hlen = sizeof (struct ip);
126 int mtu;
127 int error = 0;
128 struct sockaddr_in *dst;
129 const struct sockaddr_in *gw;
130 struct in_ifaddr *ia;
131 int isbroadcast;
132 uint16_t ip_len, ip_off;
133 struct route iproute;
134 struct rtentry *rte; /* cache for ro->ro_rt */
135 struct in_addr odst;
136 struct m_tag *fwd_tag = NULL;
137#ifdef IPSEC
138 int no_route_but_check_spd = 0;
139#endif
140 M_ASSERTPKTHDR(m);
141
142 if (inp != NULL) {
143 INP_LOCK_ASSERT(inp);
144 M_SETFIB(m, inp->inp_inc.inc_fibnum);
145 if (inp->inp_flags & (INP_HW_FLOWID|INP_SW_FLOWID)) {
146 m->m_pkthdr.flowid = inp->inp_flowid;
147 m->m_flags |= M_FLOWID;
148 }
149 }
150
151 if (ro == NULL) {
152 ro = &iproute;
153 bzero(ro, sizeof (*ro));
154 }
155
156#ifdef FLOWTABLE
157 if (ro->ro_rt == NULL)
158 (void )flowtable_lookup(AF_INET, m, ro);
159#endif
160
161 if (opt) {
162 int len = 0;
163 m = ip_insertoptions(m, opt, &len);
164 if (len != 0)
165 hlen = len; /* ip->ip_hl is updated above */
166 }
167 ip = mtod(m, struct ip *);
168 ip_len = ntohs(ip->ip_len);
169 ip_off = ntohs(ip->ip_off);
170
171 /*
172 * Fill in IP header. If we are not allowing fragmentation,
173 * then the ip_id field is meaningless, but we don't set it
174 * to zero. Doing so causes various problems when devices along
175 * the path (routers, load balancers, firewalls, etc.) illegally
176 * disable DF on our packet. Note that a 16-bit counter
177 * will wrap around in less than 10 seconds at 100 Mbit/s on a
178 * medium with MTU 1500. See Steven M. Bellovin, "A Technique
179 * for Counting NATted Hosts", Proc. IMW'02, available at
180 * <http://www.cs.columbia.edu/~smb/papers/fnat.pdf>.
181 */
182 if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
183 ip->ip_v = IPVERSION;
184 ip->ip_hl = hlen >> 2;
185 ip->ip_id = ip_newid();
186 IPSTAT_INC(ips_localout);
187 } else {
188 /* Header already set, fetch hlen from there */
189 hlen = ip->ip_hl << 2;
190 }
191
192 /*
193 * dst/gw handling:
194 *
195 * dst can be rewritten but always points to &ro->ro_dst.
196 * gw is readonly but can point either to dst OR rt_gateway,
197 * therefore we need restore gw if we're redoing lookup.
198 */
199 gw = dst = (struct sockaddr_in *)&ro->ro_dst;
200again:
201 ia = NULL;
202 /*
203 * If there is a cached route, check that it is to the same
204 * destination and is still up. If not, free it and try again.
205 * The address family should also be checked in case of sharing
206 * the cache with IPv6.
207 */
208 rte = ro->ro_rt;
209 if (rte && ((rte->rt_flags & RTF_UP) == 0 ||
210 rte->rt_ifp == NULL ||
211 !RT_LINK_IS_UP(rte->rt_ifp) ||
212 dst->sin_family != AF_INET ||
213 dst->sin_addr.s_addr != ip->ip_dst.s_addr)) {
214 RO_RTFREE(ro);
215 ro->ro_lle = NULL;
216 rte = NULL;
217 gw = dst;
218 }
219 if (rte == NULL && fwd_tag == NULL) {
220 bzero(dst, sizeof(*dst));
221 dst->sin_family = AF_INET;
222 dst->sin_len = sizeof(*dst);
223 dst->sin_addr = ip->ip_dst;
224 }
225 /*
226 * If routing to interface only, short circuit routing lookup.
227 * The use of an all-ones broadcast address implies this; an
228 * interface is specified by the broadcast address of an interface,
229 * or the destination address of a ptp interface.
230 */
231 if (flags & IP_SENDONES) {
232 if ((ia = ifatoia(ifa_ifwithbroadaddr(sintosa(dst)))) == NULL &&
233 (ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL) {
234 IPSTAT_INC(ips_noroute);
235 error = ENETUNREACH;
236 goto bad;
237 }
238 ip->ip_dst.s_addr = INADDR_BROADCAST;
239 dst->sin_addr = ip->ip_dst;
240 ifp = ia->ia_ifp;
241 ip->ip_ttl = 1;
242 isbroadcast = 1;
243 } else if (flags & IP_ROUTETOIF) {
244 if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == NULL &&
245 (ia = ifatoia(ifa_ifwithnet(sintosa(dst), 0))) == NULL) {
246 IPSTAT_INC(ips_noroute);
247 error = ENETUNREACH;
248 goto bad;
249 }
250 ifp = ia->ia_ifp;
251 ip->ip_ttl = 1;
252 isbroadcast = in_broadcast(dst->sin_addr, ifp);
253 } else if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) &&
254 imo != NULL && imo->imo_multicast_ifp != NULL) {
255 /*
256 * Bypass the normal routing lookup for multicast
257 * packets if the interface is specified.
258 */
259 ifp = imo->imo_multicast_ifp;
260 IFP_TO_IA(ifp, ia);
261 isbroadcast = 0; /* fool gcc */
262 } else {
263 /*
264 * We want to do any cloning requested by the link layer,
265 * as this is probably required in all cases for correct
266 * operation (as it is for ARP).
267 */
268 if (rte == NULL) {
269#ifdef RADIX_MPATH
270 rtalloc_mpath_fib(ro,
271 ntohl(ip->ip_src.s_addr ^ ip->ip_dst.s_addr),
272 inp ? inp->inp_inc.inc_fibnum : M_GETFIB(m));
273#else
274 in_rtalloc_ign(ro, 0,
275 inp ? inp->inp_inc.inc_fibnum : M_GETFIB(m));
276#endif
277 rte = ro->ro_rt;
278 }
279 if (rte == NULL ||
280 rte->rt_ifp == NULL ||
281 !RT_LINK_IS_UP(rte->rt_ifp)) {
282#ifdef IPSEC
283 /*
284 * There is no route for this packet, but it is
285 * possible that a matching SPD entry exists.
286 */
287 no_route_but_check_spd = 1;
288 mtu = 0; /* Silence GCC warning. */
289 goto sendit;
290#endif
291 IPSTAT_INC(ips_noroute);
292 error = EHOSTUNREACH;
293 goto bad;
294 }
295 ia = ifatoia(rte->rt_ifa);
296 ifp = rte->rt_ifp;
|
320 } else {
321 mtu = ifp->if_mtu;
322 }
323 /* Catch a possible divide by zero later. */
324 KASSERT(mtu > 0, ("%s: mtu %d <= 0, rte=%p (rt_flags=0x%08x) ifp=%p",
325 __func__, mtu, rte, (rte != NULL) ? rte->rt_flags : 0, ifp));
326 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
327 m->m_flags |= M_MCAST;
328 /*
329 * IP destination address is multicast. Make sure "gw"
330 * still points to the address in "ro". (It may have been
331 * changed to point to a gateway address, above.)
332 */
333 gw = dst;
334 /*
335 * See if the caller provided any multicast options
336 */
337 if (imo != NULL) {
338 ip->ip_ttl = imo->imo_multicast_ttl;
339 if (imo->imo_multicast_vif != -1)
340 ip->ip_src.s_addr =
341 ip_mcast_src ?
342 ip_mcast_src(imo->imo_multicast_vif) :
343 INADDR_ANY;
344 } else
345 ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
346 /*
347 * Confirm that the outgoing interface supports multicast.
348 */
349 if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
350 if ((ifp->if_flags & IFF_MULTICAST) == 0) {
351 IPSTAT_INC(ips_noroute);
352 error = ENETUNREACH;
353 goto bad;
354 }
355 }
356 /*
357 * If source address not specified yet, use address
358 * of outgoing interface.
359 */
360 if (ip->ip_src.s_addr == INADDR_ANY) {
361 /* Interface may have no addresses. */
362 if (ia != NULL)
363 ip->ip_src = IA_SIN(ia)->sin_addr;
364 }
365
366 if ((imo == NULL && in_mcast_loop) ||
367 (imo && imo->imo_multicast_loop)) {
368 /*
369 * Loop back multicast datagram if not expressly
370 * forbidden to do so, even if we are not a member
371 * of the group; ip_input() will filter it later,
372 * thus deferring a hash lookup and mutex acquisition
373 * at the expense of a cheap copy using m_copym().
374 */
375 ip_mloopback(ifp, m, dst, hlen);
376 } else {
377 /*
378 * If we are acting as a multicast router, perform
379 * multicast forwarding as if the packet had just
380 * arrived on the interface to which we are about
381 * to send. The multicast forwarding function
382 * recursively calls this function, using the
383 * IP_FORWARDING flag to prevent infinite recursion.
384 *
385 * Multicasts that are looped back by ip_mloopback(),
386 * above, will be forwarded by the ip_input() routine,
387 * if necessary.
388 */
389 if (V_ip_mrouter && (flags & IP_FORWARDING) == 0) {
390 /*
391 * If rsvp daemon is not running, do not
392 * set ip_moptions. This ensures that the packet
393 * is multicast and not just sent down one link
394 * as prescribed by rsvpd.
395 */
396 if (!V_rsvp_on)
397 imo = NULL;
398 if (ip_mforward &&
399 ip_mforward(ip, ifp, m, imo) != 0) {
400 m_freem(m);
401 goto done;
402 }
403 }
404 }
405
406 /*
407 * Multicasts with a time-to-live of zero may be looped-
408 * back, above, but must not be transmitted on a network.
409 * Also, multicasts addressed to the loopback interface
410 * are not sent -- the above call to ip_mloopback() will
411 * loop back a copy. ip_input() will drop the copy if
412 * this host does not belong to the destination group on
413 * the loopback interface.
414 */
415 if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
416 m_freem(m);
417 goto done;
418 }
419
420 goto sendit;
421 }
422
423 /*
424 * If the source address is not specified yet, use the address
425 * of the outoing interface.
426 */
427 if (ip->ip_src.s_addr == INADDR_ANY) {
428 /* Interface may have no addresses. */
429 if (ia != NULL) {
430 ip->ip_src = IA_SIN(ia)->sin_addr;
431 }
432 }
433
434 /*
435 * Both in the SMP world, pre-emption world if_transmit() world,
436 * the following code doesn't really function as intended any further.
437 *
438 * + There can and will be multiple CPUs running this code path
439 * in parallel, and we do no lock holding when checking the
440 * queue depth;
441 * + And since other threads can be running concurrently, even if
442 * we do pass this check, another thread may queue some frames
443 * before this thread does and it will end up partially or fully
444 * failing to send anyway;
445 * + if_transmit() based drivers don't necessarily set ifq_len
446 * at all.
447 *
448 * This should be replaced with a method of pushing an entire list
449 * of fragment frames to the driver and have the driver decide
450 * whether it can queue or not queue the entire set.
451 */
452#if 0
453 /*
454 * Verify that we have any chance at all of being able to queue the
455 * packet or packet fragments, unless ALTQ is enabled on the given
456 * interface in which case packetdrop should be done by queueing.
457 */
458 n = ip_len / mtu + 1; /* how many fragments ? */
459 if (
460#ifdef ALTQ
461 (!ALTQ_IS_ENABLED(&ifp->if_snd)) &&
462#endif /* ALTQ */
463 (ifp->if_snd.ifq_len + n) >= ifp->if_snd.ifq_maxlen ) {
464 error = ENOBUFS;
465 IPSTAT_INC(ips_odropped);
466 ifp->if_snd.ifq_drops += n;
467 goto bad;
468 }
469#endif
470
471 /*
472 * Look for broadcast address and
473 * verify user is allowed to send
474 * such a packet.
475 */
476 if (isbroadcast) {
477 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
478 error = EADDRNOTAVAIL;
479 goto bad;
480 }
481 if ((flags & IP_ALLOWBROADCAST) == 0) {
482 error = EACCES;
483 goto bad;
484 }
485 /* don't allow broadcast messages to be fragmented */
486 if (ip_len > mtu) {
487 error = EMSGSIZE;
488 goto bad;
489 }
490 m->m_flags |= M_BCAST;
491 } else {
492 m->m_flags &= ~M_BCAST;
493 }
494
495sendit:
496#ifdef IPSEC
497 switch(ip_ipsec_output(&m, inp, &flags, &error)) {
498 case 1:
499 goto bad;
500 case -1:
501 goto done;
502 case 0:
503 default:
504 break; /* Continue with packet processing. */
505 }
506 /*
507 * Check if there was a route for this packet; return error if not.
508 */
509 if (no_route_but_check_spd) {
510 IPSTAT_INC(ips_noroute);
511 error = EHOSTUNREACH;
512 goto bad;
513 }
514 /* Update variables that are affected by ipsec4_output(). */
515 ip = mtod(m, struct ip *);
516 hlen = ip->ip_hl << 2;
517#endif /* IPSEC */
518
519 /* Jump over all PFIL processing if hooks are not active. */
520 if (!PFIL_HOOKED(&V_inet_pfil_hook))
521 goto passout;
522
523 /* Run through list of hooks for output packets. */
524 odst.s_addr = ip->ip_dst.s_addr;
525 error = pfil_run_hooks(&V_inet_pfil_hook, &m, ifp, PFIL_OUT, inp);
526 if (error != 0 || m == NULL)
527 goto done;
528
529 ip = mtod(m, struct ip *);
530
531 /* See if destination IP address was changed by packet filter. */
532 if (odst.s_addr != ip->ip_dst.s_addr) {
533 m->m_flags |= M_SKIP_FIREWALL;
534 /* If destination is now ourself drop to ip_input(). */
535 if (in_localip(ip->ip_dst)) {
536 m->m_flags |= M_FASTFWD_OURS;
537 if (m->m_pkthdr.rcvif == NULL)
538 m->m_pkthdr.rcvif = V_loif;
539 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
540 m->m_pkthdr.csum_flags |=
541 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
542 m->m_pkthdr.csum_data = 0xffff;
543 }
544 m->m_pkthdr.csum_flags |=
545 CSUM_IP_CHECKED | CSUM_IP_VALID;
546#ifdef SCTP
547 if (m->m_pkthdr.csum_flags & CSUM_SCTP)
548 m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
549#endif
550 error = netisr_queue(NETISR_IP, m);
551 goto done;
552 } else
553 goto again; /* Redo the routing table lookup. */
554 }
555
556 /* See if local, if yes, send it to netisr with IP_FASTFWD_OURS. */
557 if (m->m_flags & M_FASTFWD_OURS) {
558 if (m->m_pkthdr.rcvif == NULL)
559 m->m_pkthdr.rcvif = V_loif;
560 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
561 m->m_pkthdr.csum_flags |=
562 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
563 m->m_pkthdr.csum_data = 0xffff;
564 }
565#ifdef SCTP
566 if (m->m_pkthdr.csum_flags & CSUM_SCTP)
567 m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
568#endif
569 m->m_pkthdr.csum_flags |=
570 CSUM_IP_CHECKED | CSUM_IP_VALID;
571
572 error = netisr_queue(NETISR_IP, m);
573 goto done;
574 }
575 /* Or forward to some other address? */
576 if ((m->m_flags & M_IP_NEXTHOP) &&
577 (fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL) {
578 bcopy((fwd_tag+1), dst, sizeof(struct sockaddr_in));
579 m->m_flags |= M_SKIP_FIREWALL;
580 m->m_flags &= ~M_IP_NEXTHOP;
581 m_tag_delete(m, fwd_tag);
582 goto again;
583 }
584
585passout:
586 /* 127/8 must not appear on wire - RFC1122. */
587 if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
588 (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
589 if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
590 IPSTAT_INC(ips_badaddr);
591 error = EADDRNOTAVAIL;
592 goto bad;
593 }
594 }
595
596 m->m_pkthdr.csum_flags |= CSUM_IP;
597 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA & ~ifp->if_hwassist) {
598 in_delayed_cksum(m);
599 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
600 }
601#ifdef SCTP
602 if (m->m_pkthdr.csum_flags & CSUM_SCTP & ~ifp->if_hwassist) {
603 sctp_delayed_cksum(m, (uint32_t)(ip->ip_hl << 2));
604 m->m_pkthdr.csum_flags &= ~CSUM_SCTP;
605 }
606#endif
607
608 /*
609 * If small enough for interface, or the interface will take
610 * care of the fragmentation for us, we can just send directly.
611 */
612 if (ip_len <= mtu ||
613 (m->m_pkthdr.csum_flags & ifp->if_hwassist & CSUM_TSO) != 0 ||
614 ((ip_off & IP_DF) == 0 && (ifp->if_hwassist & CSUM_FRAGMENT))) {
615 ip->ip_sum = 0;
616 if (m->m_pkthdr.csum_flags & CSUM_IP & ~ifp->if_hwassist) {
617 ip->ip_sum = in_cksum(m, hlen);
618 m->m_pkthdr.csum_flags &= ~CSUM_IP;
619 }
620
621 /*
622 * Record statistics for this interface address.
623 * With CSUM_TSO the byte/packet count will be slightly
624 * incorrect because we count the IP+TCP headers only
625 * once instead of for every generated packet.
626 */
627 if (!(flags & IP_FORWARDING) && ia) {
628 if (m->m_pkthdr.csum_flags & CSUM_TSO)
629 counter_u64_add(ia->ia_ifa.ifa_opackets,
630 m->m_pkthdr.len / m->m_pkthdr.tso_segsz);
631 else
632 counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
633
634 counter_u64_add(ia->ia_ifa.ifa_obytes, m->m_pkthdr.len);
635 }
636#ifdef MBUF_STRESS_TEST
637 if (mbuf_frag_size && m->m_pkthdr.len > mbuf_frag_size)
638 m = m_fragment(m, M_NOWAIT, mbuf_frag_size);
639#endif
640 /*
641 * Reset layer specific mbuf flags
642 * to avoid confusing lower layers.
643 */
644 m_clrprotoflags(m);
645 IP_PROBE(send, NULL, NULL, ip, ifp, ip, NULL);
646 error = (*ifp->if_output)(ifp, m,
647 (const struct sockaddr *)gw, ro);
648 goto done;
649 }
650
651 /* Balk when DF bit is set or the interface didn't support TSO. */
652 if ((ip_off & IP_DF) || (m->m_pkthdr.csum_flags & CSUM_TSO)) {
653 error = EMSGSIZE;
654 IPSTAT_INC(ips_cantfrag);
655 goto bad;
656 }
657
658 /*
659 * Too large for interface; fragment if possible. If successful,
660 * on return, m will point to a list of packets to be sent.
661 */
662 error = ip_fragment(ip, &m, mtu, ifp->if_hwassist);
663 if (error)
664 goto bad;
665 for (; m; m = m0) {
666 m0 = m->m_nextpkt;
667 m->m_nextpkt = 0;
668 if (error == 0) {
669 /* Record statistics for this interface address. */
670 if (ia != NULL) {
671 counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
672 counter_u64_add(ia->ia_ifa.ifa_obytes,
673 m->m_pkthdr.len);
674 }
675 /*
676 * Reset layer specific mbuf flags
677 * to avoid confusing upper layers.
678 */
679 m_clrprotoflags(m);
680
681 IP_PROBE(send, NULL, NULL, ip, ifp, ip, NULL);
682 error = (*ifp->if_output)(ifp, m,
683 (const struct sockaddr *)gw, ro);
684 } else
685 m_freem(m);
686 }
687
688 if (error == 0)
689 IPSTAT_INC(ips_fragmented);
690
691done:
692 if (ro == &iproute)
693 RO_RTFREE(ro);
694 return (error);
695bad:
696 m_freem(m);
697 goto done;
698}
699
700/*
701 * Create a chain of fragments which fit the given mtu. m_frag points to the
702 * mbuf to be fragmented; on return it points to the chain with the fragments.
703 * Return 0 if no error. If error, m_frag may contain a partially built
704 * chain of fragments that should be freed by the caller.
705 *
706 * if_hwassist_flags is the hw offload capabilities (see if_data.ifi_hwassist)
707 */
708int
709ip_fragment(struct ip *ip, struct mbuf **m_frag, int mtu,
710 u_long if_hwassist_flags)
711{
712 int error = 0;
713 int hlen = ip->ip_hl << 2;
714 int len = (mtu - hlen) & ~7; /* size of payload in each fragment */
715 int off;
716 struct mbuf *m0 = *m_frag; /* the original packet */
717 int firstlen;
718 struct mbuf **mnext;
719 int nfrags;
720 uint16_t ip_len, ip_off;
721
722 ip_len = ntohs(ip->ip_len);
723 ip_off = ntohs(ip->ip_off);
724
725 if (ip_off & IP_DF) { /* Fragmentation not allowed */
726 IPSTAT_INC(ips_cantfrag);
727 return EMSGSIZE;
728 }
729
730 /*
731 * Must be able to put at least 8 bytes per fragment.
732 */
733 if (len < 8)
734 return EMSGSIZE;
735
736 /*
737 * If the interface will not calculate checksums on
738 * fragmented packets, then do it here.
739 */
740 if (m0->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
741 in_delayed_cksum(m0);
742 m0->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
743 }
744#ifdef SCTP
745 if (m0->m_pkthdr.csum_flags & CSUM_SCTP) {
746 sctp_delayed_cksum(m0, hlen);
747 m0->m_pkthdr.csum_flags &= ~CSUM_SCTP;
748 }
749#endif
750 if (len > PAGE_SIZE) {
751 /*
752 * Fragment large datagrams such that each segment
753 * contains a multiple of PAGE_SIZE amount of data,
754 * plus headers. This enables a receiver to perform
755 * page-flipping zero-copy optimizations.
756 *
757 * XXX When does this help given that sender and receiver
758 * could have different page sizes, and also mtu could
759 * be less than the receiver's page size ?
760 */
761 int newlen;
762 struct mbuf *m;
763
764 for (m = m0, off = 0; m && (off+m->m_len) <= mtu; m = m->m_next)
765 off += m->m_len;
766
767 /*
768 * firstlen (off - hlen) must be aligned on an
769 * 8-byte boundary
770 */
771 if (off < hlen)
772 goto smart_frag_failure;
773 off = ((off - hlen) & ~7) + hlen;
774 newlen = (~PAGE_MASK) & mtu;
775 if ((newlen + sizeof (struct ip)) > mtu) {
776 /* we failed, go back the default */
777smart_frag_failure:
778 newlen = len;
779 off = hlen + len;
780 }
781 len = newlen;
782
783 } else {
784 off = hlen + len;
785 }
786
787 firstlen = off - hlen;
788 mnext = &m0->m_nextpkt; /* pointer to next packet */
789
790 /*
791 * Loop through length of segment after first fragment,
792 * make new header and copy data of each part and link onto chain.
793 * Here, m0 is the original packet, m is the fragment being created.
794 * The fragments are linked off the m_nextpkt of the original
795 * packet, which after processing serves as the first fragment.
796 */
797 for (nfrags = 1; off < ip_len; off += len, nfrags++) {
798 struct ip *mhip; /* ip header on the fragment */
799 struct mbuf *m;
800 int mhlen = sizeof (struct ip);
801
802 m = m_gethdr(M_NOWAIT, MT_DATA);
803 if (m == NULL) {
804 error = ENOBUFS;
805 IPSTAT_INC(ips_odropped);
806 goto done;
807 }
808 m->m_flags |= (m0->m_flags & M_MCAST);
809 /*
810 * In the first mbuf, leave room for the link header, then
811 * copy the original IP header including options. The payload
812 * goes into an additional mbuf chain returned by m_copym().
813 */
814 m->m_data += max_linkhdr;
815 mhip = mtod(m, struct ip *);
816 *mhip = *ip;
817 if (hlen > sizeof (struct ip)) {
818 mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
819 mhip->ip_v = IPVERSION;
820 mhip->ip_hl = mhlen >> 2;
821 }
822 m->m_len = mhlen;
823 /* XXX do we need to add ip_off below ? */
824 mhip->ip_off = ((off - hlen) >> 3) + ip_off;
825 if (off + len >= ip_len)
826 len = ip_len - off;
827 else
828 mhip->ip_off |= IP_MF;
829 mhip->ip_len = htons((u_short)(len + mhlen));
830 m->m_next = m_copym(m0, off, len, M_NOWAIT);
831 if (m->m_next == NULL) { /* copy failed */
832 m_free(m);
833 error = ENOBUFS; /* ??? */
834 IPSTAT_INC(ips_odropped);
835 goto done;
836 }
837 m->m_pkthdr.len = mhlen + len;
838 m->m_pkthdr.rcvif = NULL;
839#ifdef MAC
840 mac_netinet_fragment(m0, m);
841#endif
842 m->m_pkthdr.csum_flags = m0->m_pkthdr.csum_flags;
843 mhip->ip_off = htons(mhip->ip_off);
844 mhip->ip_sum = 0;
845 if (m->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
846 mhip->ip_sum = in_cksum(m, mhlen);
847 m->m_pkthdr.csum_flags &= ~CSUM_IP;
848 }
849 *mnext = m;
850 mnext = &m->m_nextpkt;
851 }
852 IPSTAT_ADD(ips_ofragments, nfrags);
853
854 /*
855 * Update first fragment by trimming what's been copied out
856 * and updating header.
857 */
858 m_adj(m0, hlen + firstlen - ip_len);
859 m0->m_pkthdr.len = hlen + firstlen;
860 ip->ip_len = htons((u_short)m0->m_pkthdr.len);
861 ip->ip_off = htons(ip_off | IP_MF);
862 ip->ip_sum = 0;
863 if (m0->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
864 ip->ip_sum = in_cksum(m0, hlen);
865 m0->m_pkthdr.csum_flags &= ~CSUM_IP;
866 }
867
868done:
869 *m_frag = m0;
870 return error;
871}
872
873void
874in_delayed_cksum(struct mbuf *m)
875{
876 struct ip *ip;
877 uint16_t csum, offset, ip_len;
878
879 ip = mtod(m, struct ip *);
880 offset = ip->ip_hl << 2 ;
881 ip_len = ntohs(ip->ip_len);
882 csum = in_cksum_skip(m, ip_len, offset);
883 if (m->m_pkthdr.csum_flags & CSUM_UDP && csum == 0)
884 csum = 0xffff;
885 offset += m->m_pkthdr.csum_data; /* checksum offset */
886
887 if (offset + sizeof(u_short) > m->m_len) {
888 printf("delayed m_pullup, m->len: %d off: %d p: %d\n",
889 m->m_len, offset, ip->ip_p);
890 /*
891 * XXX
892 * this shouldn't happen, but if it does, the
893 * correct behavior may be to insert the checksum
894 * in the appropriate next mbuf in the chain.
895 */
896 return;
897 }
898 *(u_short *)(m->m_data + offset) = csum;
899}
900
901/*
902 * IP socket option processing.
903 */
904int
905ip_ctloutput(struct socket *so, struct sockopt *sopt)
906{
907 struct inpcb *inp = sotoinpcb(so);
908 int error, optval;
909
910 error = optval = 0;
911 if (sopt->sopt_level != IPPROTO_IP) {
912 error = EINVAL;
913
914 if (sopt->sopt_level == SOL_SOCKET &&
915 sopt->sopt_dir == SOPT_SET) {
916 switch (sopt->sopt_name) {
917 case SO_REUSEADDR:
918 INP_WLOCK(inp);
919 if ((so->so_options & SO_REUSEADDR) != 0)
920 inp->inp_flags2 |= INP_REUSEADDR;
921 else
922 inp->inp_flags2 &= ~INP_REUSEADDR;
923 INP_WUNLOCK(inp);
924 error = 0;
925 break;
926 case SO_REUSEPORT:
927 INP_WLOCK(inp);
928 if ((so->so_options & SO_REUSEPORT) != 0)
929 inp->inp_flags2 |= INP_REUSEPORT;
930 else
931 inp->inp_flags2 &= ~INP_REUSEPORT;
932 INP_WUNLOCK(inp);
933 error = 0;
934 break;
935 case SO_SETFIB:
936 INP_WLOCK(inp);
937 inp->inp_inc.inc_fibnum = so->so_fibnum;
938 INP_WUNLOCK(inp);
939 error = 0;
940 break;
941 default:
942 break;
943 }
944 }
945 return (error);
946 }
947
948 switch (sopt->sopt_dir) {
949 case SOPT_SET:
950 switch (sopt->sopt_name) {
951 case IP_OPTIONS:
952#ifdef notyet
953 case IP_RETOPTS:
954#endif
955 {
956 struct mbuf *m;
957 if (sopt->sopt_valsize > MLEN) {
958 error = EMSGSIZE;
959 break;
960 }
961 m = m_get(sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
962 if (m == NULL) {
963 error = ENOBUFS;
964 break;
965 }
966 m->m_len = sopt->sopt_valsize;
967 error = sooptcopyin(sopt, mtod(m, char *), m->m_len,
968 m->m_len);
969 if (error) {
970 m_free(m);
971 break;
972 }
973 INP_WLOCK(inp);
974 error = ip_pcbopts(inp, sopt->sopt_name, m);
975 INP_WUNLOCK(inp);
976 return (error);
977 }
978
979 case IP_BINDANY:
980 if (sopt->sopt_td != NULL) {
981 error = priv_check(sopt->sopt_td,
982 PRIV_NETINET_BINDANY);
983 if (error)
984 break;
985 }
986 /* FALLTHROUGH */
987 case IP_TOS:
988 case IP_TTL:
989 case IP_MINTTL:
990 case IP_RECVOPTS:
991 case IP_RECVRETOPTS:
992 case IP_RECVDSTADDR:
993 case IP_RECVTTL:
994 case IP_RECVIF:
995 case IP_FAITH:
996 case IP_ONESBCAST:
997 case IP_DONTFRAG:
998 case IP_RECVTOS:
999 error = sooptcopyin(sopt, &optval, sizeof optval,
1000 sizeof optval);
1001 if (error)
1002 break;
1003
1004 switch (sopt->sopt_name) {
1005 case IP_TOS:
1006 inp->inp_ip_tos = optval;
1007 break;
1008
1009 case IP_TTL:
1010 inp->inp_ip_ttl = optval;
1011 break;
1012
1013 case IP_MINTTL:
1014 if (optval >= 0 && optval <= MAXTTL)
1015 inp->inp_ip_minttl = optval;
1016 else
1017 error = EINVAL;
1018 break;
1019
1020#define OPTSET(bit) do { \
1021 INP_WLOCK(inp); \
1022 if (optval) \
1023 inp->inp_flags |= bit; \
1024 else \
1025 inp->inp_flags &= ~bit; \
1026 INP_WUNLOCK(inp); \
1027} while (0)
1028
1029 case IP_RECVOPTS:
1030 OPTSET(INP_RECVOPTS);
1031 break;
1032
1033 case IP_RECVRETOPTS:
1034 OPTSET(INP_RECVRETOPTS);
1035 break;
1036
1037 case IP_RECVDSTADDR:
1038 OPTSET(INP_RECVDSTADDR);
1039 break;
1040
1041 case IP_RECVTTL:
1042 OPTSET(INP_RECVTTL);
1043 break;
1044
1045 case IP_RECVIF:
1046 OPTSET(INP_RECVIF);
1047 break;
1048
1049 case IP_FAITH:
1050 OPTSET(INP_FAITH);
1051 break;
1052
1053 case IP_ONESBCAST:
1054 OPTSET(INP_ONESBCAST);
1055 break;
1056 case IP_DONTFRAG:
1057 OPTSET(INP_DONTFRAG);
1058 break;
1059 case IP_BINDANY:
1060 OPTSET(INP_BINDANY);
1061 break;
1062 case IP_RECVTOS:
1063 OPTSET(INP_RECVTOS);
1064 break;
1065 }
1066 break;
1067#undef OPTSET
1068
1069 /*
1070 * Multicast socket options are processed by the in_mcast
1071 * module.
1072 */
1073 case IP_MULTICAST_IF:
1074 case IP_MULTICAST_VIF:
1075 case IP_MULTICAST_TTL:
1076 case IP_MULTICAST_LOOP:
1077 case IP_ADD_MEMBERSHIP:
1078 case IP_DROP_MEMBERSHIP:
1079 case IP_ADD_SOURCE_MEMBERSHIP:
1080 case IP_DROP_SOURCE_MEMBERSHIP:
1081 case IP_BLOCK_SOURCE:
1082 case IP_UNBLOCK_SOURCE:
1083 case IP_MSFILTER:
1084 case MCAST_JOIN_GROUP:
1085 case MCAST_LEAVE_GROUP:
1086 case MCAST_JOIN_SOURCE_GROUP:
1087 case MCAST_LEAVE_SOURCE_GROUP:
1088 case MCAST_BLOCK_SOURCE:
1089 case MCAST_UNBLOCK_SOURCE:
1090 error = inp_setmoptions(inp, sopt);
1091 break;
1092
1093 case IP_PORTRANGE:
1094 error = sooptcopyin(sopt, &optval, sizeof optval,
1095 sizeof optval);
1096 if (error)
1097 break;
1098
1099 INP_WLOCK(inp);
1100 switch (optval) {
1101 case IP_PORTRANGE_DEFAULT:
1102 inp->inp_flags &= ~(INP_LOWPORT);
1103 inp->inp_flags &= ~(INP_HIGHPORT);
1104 break;
1105
1106 case IP_PORTRANGE_HIGH:
1107 inp->inp_flags &= ~(INP_LOWPORT);
1108 inp->inp_flags |= INP_HIGHPORT;
1109 break;
1110
1111 case IP_PORTRANGE_LOW:
1112 inp->inp_flags &= ~(INP_HIGHPORT);
1113 inp->inp_flags |= INP_LOWPORT;
1114 break;
1115
1116 default:
1117 error = EINVAL;
1118 break;
1119 }
1120 INP_WUNLOCK(inp);
1121 break;
1122
1123#ifdef IPSEC
1124 case IP_IPSEC_POLICY:
1125 {
1126 caddr_t req;
1127 struct mbuf *m;
1128
1129 if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */
1130 break;
1131 if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */
1132 break;
1133 req = mtod(m, caddr_t);
1134 error = ipsec_set_policy(inp, sopt->sopt_name, req,
1135 m->m_len, (sopt->sopt_td != NULL) ?
1136 sopt->sopt_td->td_ucred : NULL);
1137 m_freem(m);
1138 break;
1139 }
1140#endif /* IPSEC */
1141
1142 default:
1143 error = ENOPROTOOPT;
1144 break;
1145 }
1146 break;
1147
1148 case SOPT_GET:
1149 switch (sopt->sopt_name) {
1150 case IP_OPTIONS:
1151 case IP_RETOPTS:
1152 if (inp->inp_options)
1153 error = sooptcopyout(sopt,
1154 mtod(inp->inp_options,
1155 char *),
1156 inp->inp_options->m_len);
1157 else
1158 sopt->sopt_valsize = 0;
1159 break;
1160
1161 case IP_TOS:
1162 case IP_TTL:
1163 case IP_MINTTL:
1164 case IP_RECVOPTS:
1165 case IP_RECVRETOPTS:
1166 case IP_RECVDSTADDR:
1167 case IP_RECVTTL:
1168 case IP_RECVIF:
1169 case IP_PORTRANGE:
1170 case IP_FAITH:
1171 case IP_ONESBCAST:
1172 case IP_DONTFRAG:
1173 case IP_BINDANY:
1174 case IP_RECVTOS:
1175 switch (sopt->sopt_name) {
1176
1177 case IP_TOS:
1178 optval = inp->inp_ip_tos;
1179 break;
1180
1181 case IP_TTL:
1182 optval = inp->inp_ip_ttl;
1183 break;
1184
1185 case IP_MINTTL:
1186 optval = inp->inp_ip_minttl;
1187 break;
1188
1189#define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
1190
1191 case IP_RECVOPTS:
1192 optval = OPTBIT(INP_RECVOPTS);
1193 break;
1194
1195 case IP_RECVRETOPTS:
1196 optval = OPTBIT(INP_RECVRETOPTS);
1197 break;
1198
1199 case IP_RECVDSTADDR:
1200 optval = OPTBIT(INP_RECVDSTADDR);
1201 break;
1202
1203 case IP_RECVTTL:
1204 optval = OPTBIT(INP_RECVTTL);
1205 break;
1206
1207 case IP_RECVIF:
1208 optval = OPTBIT(INP_RECVIF);
1209 break;
1210
1211 case IP_PORTRANGE:
1212 if (inp->inp_flags & INP_HIGHPORT)
1213 optval = IP_PORTRANGE_HIGH;
1214 else if (inp->inp_flags & INP_LOWPORT)
1215 optval = IP_PORTRANGE_LOW;
1216 else
1217 optval = 0;
1218 break;
1219
1220 case IP_FAITH:
1221 optval = OPTBIT(INP_FAITH);
1222 break;
1223
1224 case IP_ONESBCAST:
1225 optval = OPTBIT(INP_ONESBCAST);
1226 break;
1227 case IP_DONTFRAG:
1228 optval = OPTBIT(INP_DONTFRAG);
1229 break;
1230 case IP_BINDANY:
1231 optval = OPTBIT(INP_BINDANY);
1232 break;
1233 case IP_RECVTOS:
1234 optval = OPTBIT(INP_RECVTOS);
1235 break;
1236 }
1237 error = sooptcopyout(sopt, &optval, sizeof optval);
1238 break;
1239
1240 /*
1241 * Multicast socket options are processed by the in_mcast
1242 * module.
1243 */
1244 case IP_MULTICAST_IF:
1245 case IP_MULTICAST_VIF:
1246 case IP_MULTICAST_TTL:
1247 case IP_MULTICAST_LOOP:
1248 case IP_MSFILTER:
1249 error = inp_getmoptions(inp, sopt);
1250 break;
1251
1252#ifdef IPSEC
1253 case IP_IPSEC_POLICY:
1254 {
1255 struct mbuf *m = NULL;
1256 caddr_t req = NULL;
1257 size_t len = 0;
1258
1259 if (m != 0) {
1260 req = mtod(m, caddr_t);
1261 len = m->m_len;
1262 }
1263 error = ipsec_get_policy(sotoinpcb(so), req, len, &m);
1264 if (error == 0)
1265 error = soopt_mcopyout(sopt, m); /* XXX */
1266 if (error == 0)
1267 m_freem(m);
1268 break;
1269 }
1270#endif /* IPSEC */
1271
1272 default:
1273 error = ENOPROTOOPT;
1274 break;
1275 }
1276 break;
1277 }
1278 return (error);
1279}
1280
1281/*
1282 * Routine called from ip_output() to loop back a copy of an IP multicast
1283 * packet to the input queue of a specified interface. Note that this
1284 * calls the output routine of the loopback "driver", but with an interface
1285 * pointer that might NOT be a loopback interface -- evil, but easier than
1286 * replicating that code here.
1287 */
1288static void
1289ip_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in *dst,
1290 int hlen)
1291{
1292 register struct ip *ip;
1293 struct mbuf *copym;
1294
1295 /*
1296 * Make a deep copy of the packet because we're going to
1297 * modify the pack in order to generate checksums.
1298 */
1299 copym = m_dup(m, M_NOWAIT);
1300 if (copym != NULL && (copym->m_flags & M_EXT || copym->m_len < hlen))
1301 copym = m_pullup(copym, hlen);
1302 if (copym != NULL) {
1303 /* If needed, compute the checksum and mark it as valid. */
1304 if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
1305 in_delayed_cksum(copym);
1306 copym->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
1307 copym->m_pkthdr.csum_flags |=
1308 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1309 copym->m_pkthdr.csum_data = 0xffff;
1310 }
1311 /*
1312 * We don't bother to fragment if the IP length is greater
1313 * than the interface's MTU. Can this possibly matter?
1314 */
1315 ip = mtod(copym, struct ip *);
1316 ip->ip_sum = 0;
1317 ip->ip_sum = in_cksum(copym, hlen);
1318#if 1 /* XXX */
1319 if (dst->sin_family != AF_INET) {
1320 printf("ip_mloopback: bad address family %d\n",
1321 dst->sin_family);
1322 dst->sin_family = AF_INET;
1323 }
1324#endif
1325 if_simloop(ifp, copym, dst->sin_family, 0);
1326 }
1327}
| 320 } else {
321 mtu = ifp->if_mtu;
322 }
323 /* Catch a possible divide by zero later. */
324 KASSERT(mtu > 0, ("%s: mtu %d <= 0, rte=%p (rt_flags=0x%08x) ifp=%p",
325 __func__, mtu, rte, (rte != NULL) ? rte->rt_flags : 0, ifp));
326 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
327 m->m_flags |= M_MCAST;
328 /*
329 * IP destination address is multicast. Make sure "gw"
330 * still points to the address in "ro". (It may have been
331 * changed to point to a gateway address, above.)
332 */
333 gw = dst;
334 /*
335 * See if the caller provided any multicast options
336 */
337 if (imo != NULL) {
338 ip->ip_ttl = imo->imo_multicast_ttl;
339 if (imo->imo_multicast_vif != -1)
340 ip->ip_src.s_addr =
341 ip_mcast_src ?
342 ip_mcast_src(imo->imo_multicast_vif) :
343 INADDR_ANY;
344 } else
345 ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
346 /*
347 * Confirm that the outgoing interface supports multicast.
348 */
349 if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
350 if ((ifp->if_flags & IFF_MULTICAST) == 0) {
351 IPSTAT_INC(ips_noroute);
352 error = ENETUNREACH;
353 goto bad;
354 }
355 }
356 /*
357 * If source address not specified yet, use address
358 * of outgoing interface.
359 */
360 if (ip->ip_src.s_addr == INADDR_ANY) {
361 /* Interface may have no addresses. */
362 if (ia != NULL)
363 ip->ip_src = IA_SIN(ia)->sin_addr;
364 }
365
366 if ((imo == NULL && in_mcast_loop) ||
367 (imo && imo->imo_multicast_loop)) {
368 /*
369 * Loop back multicast datagram if not expressly
370 * forbidden to do so, even if we are not a member
371 * of the group; ip_input() will filter it later,
372 * thus deferring a hash lookup and mutex acquisition
373 * at the expense of a cheap copy using m_copym().
374 */
375 ip_mloopback(ifp, m, dst, hlen);
376 } else {
377 /*
378 * If we are acting as a multicast router, perform
379 * multicast forwarding as if the packet had just
380 * arrived on the interface to which we are about
381 * to send. The multicast forwarding function
382 * recursively calls this function, using the
383 * IP_FORWARDING flag to prevent infinite recursion.
384 *
385 * Multicasts that are looped back by ip_mloopback(),
386 * above, will be forwarded by the ip_input() routine,
387 * if necessary.
388 */
389 if (V_ip_mrouter && (flags & IP_FORWARDING) == 0) {
390 /*
391 * If rsvp daemon is not running, do not
392 * set ip_moptions. This ensures that the packet
393 * is multicast and not just sent down one link
394 * as prescribed by rsvpd.
395 */
396 if (!V_rsvp_on)
397 imo = NULL;
398 if (ip_mforward &&
399 ip_mforward(ip, ifp, m, imo) != 0) {
400 m_freem(m);
401 goto done;
402 }
403 }
404 }
405
406 /*
407 * Multicasts with a time-to-live of zero may be looped-
408 * back, above, but must not be transmitted on a network.
409 * Also, multicasts addressed to the loopback interface
410 * are not sent -- the above call to ip_mloopback() will
411 * loop back a copy. ip_input() will drop the copy if
412 * this host does not belong to the destination group on
413 * the loopback interface.
414 */
415 if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
416 m_freem(m);
417 goto done;
418 }
419
420 goto sendit;
421 }
422
423 /*
424 * If the source address is not specified yet, use the address
425 * of the outoing interface.
426 */
427 if (ip->ip_src.s_addr == INADDR_ANY) {
428 /* Interface may have no addresses. */
429 if (ia != NULL) {
430 ip->ip_src = IA_SIN(ia)->sin_addr;
431 }
432 }
433
434 /*
435 * Both in the SMP world, pre-emption world if_transmit() world,
436 * the following code doesn't really function as intended any further.
437 *
438 * + There can and will be multiple CPUs running this code path
439 * in parallel, and we do no lock holding when checking the
440 * queue depth;
441 * + And since other threads can be running concurrently, even if
442 * we do pass this check, another thread may queue some frames
443 * before this thread does and it will end up partially or fully
444 * failing to send anyway;
445 * + if_transmit() based drivers don't necessarily set ifq_len
446 * at all.
447 *
448 * This should be replaced with a method of pushing an entire list
449 * of fragment frames to the driver and have the driver decide
450 * whether it can queue or not queue the entire set.
451 */
452#if 0
453 /*
454 * Verify that we have any chance at all of being able to queue the
455 * packet or packet fragments, unless ALTQ is enabled on the given
456 * interface in which case packetdrop should be done by queueing.
457 */
458 n = ip_len / mtu + 1; /* how many fragments ? */
459 if (
460#ifdef ALTQ
461 (!ALTQ_IS_ENABLED(&ifp->if_snd)) &&
462#endif /* ALTQ */
463 (ifp->if_snd.ifq_len + n) >= ifp->if_snd.ifq_maxlen ) {
464 error = ENOBUFS;
465 IPSTAT_INC(ips_odropped);
466 ifp->if_snd.ifq_drops += n;
467 goto bad;
468 }
469#endif
470
471 /*
472 * Look for broadcast address and
473 * verify user is allowed to send
474 * such a packet.
475 */
476 if (isbroadcast) {
477 if ((ifp->if_flags & IFF_BROADCAST) == 0) {
478 error = EADDRNOTAVAIL;
479 goto bad;
480 }
481 if ((flags & IP_ALLOWBROADCAST) == 0) {
482 error = EACCES;
483 goto bad;
484 }
485 /* don't allow broadcast messages to be fragmented */
486 if (ip_len > mtu) {
487 error = EMSGSIZE;
488 goto bad;
489 }
490 m->m_flags |= M_BCAST;
491 } else {
492 m->m_flags &= ~M_BCAST;
493 }
494
495sendit:
496#ifdef IPSEC
497 switch(ip_ipsec_output(&m, inp, &flags, &error)) {
498 case 1:
499 goto bad;
500 case -1:
501 goto done;
502 case 0:
503 default:
504 break; /* Continue with packet processing. */
505 }
506 /*
507 * Check if there was a route for this packet; return error if not.
508 */
509 if (no_route_but_check_spd) {
510 IPSTAT_INC(ips_noroute);
511 error = EHOSTUNREACH;
512 goto bad;
513 }
514 /* Update variables that are affected by ipsec4_output(). */
515 ip = mtod(m, struct ip *);
516 hlen = ip->ip_hl << 2;
517#endif /* IPSEC */
518
519 /* Jump over all PFIL processing if hooks are not active. */
520 if (!PFIL_HOOKED(&V_inet_pfil_hook))
521 goto passout;
522
523 /* Run through list of hooks for output packets. */
524 odst.s_addr = ip->ip_dst.s_addr;
525 error = pfil_run_hooks(&V_inet_pfil_hook, &m, ifp, PFIL_OUT, inp);
526 if (error != 0 || m == NULL)
527 goto done;
528
529 ip = mtod(m, struct ip *);
530
531 /* See if destination IP address was changed by packet filter. */
532 if (odst.s_addr != ip->ip_dst.s_addr) {
533 m->m_flags |= M_SKIP_FIREWALL;
534 /* If destination is now ourself drop to ip_input(). */
535 if (in_localip(ip->ip_dst)) {
536 m->m_flags |= M_FASTFWD_OURS;
537 if (m->m_pkthdr.rcvif == NULL)
538 m->m_pkthdr.rcvif = V_loif;
539 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
540 m->m_pkthdr.csum_flags |=
541 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
542 m->m_pkthdr.csum_data = 0xffff;
543 }
544 m->m_pkthdr.csum_flags |=
545 CSUM_IP_CHECKED | CSUM_IP_VALID;
546#ifdef SCTP
547 if (m->m_pkthdr.csum_flags & CSUM_SCTP)
548 m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
549#endif
550 error = netisr_queue(NETISR_IP, m);
551 goto done;
552 } else
553 goto again; /* Redo the routing table lookup. */
554 }
555
556 /* See if local, if yes, send it to netisr with IP_FASTFWD_OURS. */
557 if (m->m_flags & M_FASTFWD_OURS) {
558 if (m->m_pkthdr.rcvif == NULL)
559 m->m_pkthdr.rcvif = V_loif;
560 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
561 m->m_pkthdr.csum_flags |=
562 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
563 m->m_pkthdr.csum_data = 0xffff;
564 }
565#ifdef SCTP
566 if (m->m_pkthdr.csum_flags & CSUM_SCTP)
567 m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID;
568#endif
569 m->m_pkthdr.csum_flags |=
570 CSUM_IP_CHECKED | CSUM_IP_VALID;
571
572 error = netisr_queue(NETISR_IP, m);
573 goto done;
574 }
575 /* Or forward to some other address? */
576 if ((m->m_flags & M_IP_NEXTHOP) &&
577 (fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL) {
578 bcopy((fwd_tag+1), dst, sizeof(struct sockaddr_in));
579 m->m_flags |= M_SKIP_FIREWALL;
580 m->m_flags &= ~M_IP_NEXTHOP;
581 m_tag_delete(m, fwd_tag);
582 goto again;
583 }
584
585passout:
586 /* 127/8 must not appear on wire - RFC1122. */
587 if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
588 (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
589 if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
590 IPSTAT_INC(ips_badaddr);
591 error = EADDRNOTAVAIL;
592 goto bad;
593 }
594 }
595
596 m->m_pkthdr.csum_flags |= CSUM_IP;
597 if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA & ~ifp->if_hwassist) {
598 in_delayed_cksum(m);
599 m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
600 }
601#ifdef SCTP
602 if (m->m_pkthdr.csum_flags & CSUM_SCTP & ~ifp->if_hwassist) {
603 sctp_delayed_cksum(m, (uint32_t)(ip->ip_hl << 2));
604 m->m_pkthdr.csum_flags &= ~CSUM_SCTP;
605 }
606#endif
607
608 /*
609 * If small enough for interface, or the interface will take
610 * care of the fragmentation for us, we can just send directly.
611 */
612 if (ip_len <= mtu ||
613 (m->m_pkthdr.csum_flags & ifp->if_hwassist & CSUM_TSO) != 0 ||
614 ((ip_off & IP_DF) == 0 && (ifp->if_hwassist & CSUM_FRAGMENT))) {
615 ip->ip_sum = 0;
616 if (m->m_pkthdr.csum_flags & CSUM_IP & ~ifp->if_hwassist) {
617 ip->ip_sum = in_cksum(m, hlen);
618 m->m_pkthdr.csum_flags &= ~CSUM_IP;
619 }
620
621 /*
622 * Record statistics for this interface address.
623 * With CSUM_TSO the byte/packet count will be slightly
624 * incorrect because we count the IP+TCP headers only
625 * once instead of for every generated packet.
626 */
627 if (!(flags & IP_FORWARDING) && ia) {
628 if (m->m_pkthdr.csum_flags & CSUM_TSO)
629 counter_u64_add(ia->ia_ifa.ifa_opackets,
630 m->m_pkthdr.len / m->m_pkthdr.tso_segsz);
631 else
632 counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
633
634 counter_u64_add(ia->ia_ifa.ifa_obytes, m->m_pkthdr.len);
635 }
636#ifdef MBUF_STRESS_TEST
637 if (mbuf_frag_size && m->m_pkthdr.len > mbuf_frag_size)
638 m = m_fragment(m, M_NOWAIT, mbuf_frag_size);
639#endif
640 /*
641 * Reset layer specific mbuf flags
642 * to avoid confusing lower layers.
643 */
644 m_clrprotoflags(m);
645 IP_PROBE(send, NULL, NULL, ip, ifp, ip, NULL);
646 error = (*ifp->if_output)(ifp, m,
647 (const struct sockaddr *)gw, ro);
648 goto done;
649 }
650
651 /* Balk when DF bit is set or the interface didn't support TSO. */
652 if ((ip_off & IP_DF) || (m->m_pkthdr.csum_flags & CSUM_TSO)) {
653 error = EMSGSIZE;
654 IPSTAT_INC(ips_cantfrag);
655 goto bad;
656 }
657
658 /*
659 * Too large for interface; fragment if possible. If successful,
660 * on return, m will point to a list of packets to be sent.
661 */
662 error = ip_fragment(ip, &m, mtu, ifp->if_hwassist);
663 if (error)
664 goto bad;
665 for (; m; m = m0) {
666 m0 = m->m_nextpkt;
667 m->m_nextpkt = 0;
668 if (error == 0) {
669 /* Record statistics for this interface address. */
670 if (ia != NULL) {
671 counter_u64_add(ia->ia_ifa.ifa_opackets, 1);
672 counter_u64_add(ia->ia_ifa.ifa_obytes,
673 m->m_pkthdr.len);
674 }
675 /*
676 * Reset layer specific mbuf flags
677 * to avoid confusing upper layers.
678 */
679 m_clrprotoflags(m);
680
681 IP_PROBE(send, NULL, NULL, ip, ifp, ip, NULL);
682 error = (*ifp->if_output)(ifp, m,
683 (const struct sockaddr *)gw, ro);
684 } else
685 m_freem(m);
686 }
687
688 if (error == 0)
689 IPSTAT_INC(ips_fragmented);
690
691done:
692 if (ro == &iproute)
693 RO_RTFREE(ro);
694 return (error);
695bad:
696 m_freem(m);
697 goto done;
698}
699
700/*
701 * Create a chain of fragments which fit the given mtu. m_frag points to the
702 * mbuf to be fragmented; on return it points to the chain with the fragments.
703 * Return 0 if no error. If error, m_frag may contain a partially built
704 * chain of fragments that should be freed by the caller.
705 *
706 * if_hwassist_flags is the hw offload capabilities (see if_data.ifi_hwassist)
707 */
708int
709ip_fragment(struct ip *ip, struct mbuf **m_frag, int mtu,
710 u_long if_hwassist_flags)
711{
712 int error = 0;
713 int hlen = ip->ip_hl << 2;
714 int len = (mtu - hlen) & ~7; /* size of payload in each fragment */
715 int off;
716 struct mbuf *m0 = *m_frag; /* the original packet */
717 int firstlen;
718 struct mbuf **mnext;
719 int nfrags;
720 uint16_t ip_len, ip_off;
721
722 ip_len = ntohs(ip->ip_len);
723 ip_off = ntohs(ip->ip_off);
724
725 if (ip_off & IP_DF) { /* Fragmentation not allowed */
726 IPSTAT_INC(ips_cantfrag);
727 return EMSGSIZE;
728 }
729
730 /*
731 * Must be able to put at least 8 bytes per fragment.
732 */
733 if (len < 8)
734 return EMSGSIZE;
735
736 /*
737 * If the interface will not calculate checksums on
738 * fragmented packets, then do it here.
739 */
740 if (m0->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
741 in_delayed_cksum(m0);
742 m0->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
743 }
744#ifdef SCTP
745 if (m0->m_pkthdr.csum_flags & CSUM_SCTP) {
746 sctp_delayed_cksum(m0, hlen);
747 m0->m_pkthdr.csum_flags &= ~CSUM_SCTP;
748 }
749#endif
750 if (len > PAGE_SIZE) {
751 /*
752 * Fragment large datagrams such that each segment
753 * contains a multiple of PAGE_SIZE amount of data,
754 * plus headers. This enables a receiver to perform
755 * page-flipping zero-copy optimizations.
756 *
757 * XXX When does this help given that sender and receiver
758 * could have different page sizes, and also mtu could
759 * be less than the receiver's page size ?
760 */
761 int newlen;
762 struct mbuf *m;
763
764 for (m = m0, off = 0; m && (off+m->m_len) <= mtu; m = m->m_next)
765 off += m->m_len;
766
767 /*
768 * firstlen (off - hlen) must be aligned on an
769 * 8-byte boundary
770 */
771 if (off < hlen)
772 goto smart_frag_failure;
773 off = ((off - hlen) & ~7) + hlen;
774 newlen = (~PAGE_MASK) & mtu;
775 if ((newlen + sizeof (struct ip)) > mtu) {
776 /* we failed, go back the default */
777smart_frag_failure:
778 newlen = len;
779 off = hlen + len;
780 }
781 len = newlen;
782
783 } else {
784 off = hlen + len;
785 }
786
787 firstlen = off - hlen;
788 mnext = &m0->m_nextpkt; /* pointer to next packet */
789
790 /*
791 * Loop through length of segment after first fragment,
792 * make new header and copy data of each part and link onto chain.
793 * Here, m0 is the original packet, m is the fragment being created.
794 * The fragments are linked off the m_nextpkt of the original
795 * packet, which after processing serves as the first fragment.
796 */
797 for (nfrags = 1; off < ip_len; off += len, nfrags++) {
798 struct ip *mhip; /* ip header on the fragment */
799 struct mbuf *m;
800 int mhlen = sizeof (struct ip);
801
802 m = m_gethdr(M_NOWAIT, MT_DATA);
803 if (m == NULL) {
804 error = ENOBUFS;
805 IPSTAT_INC(ips_odropped);
806 goto done;
807 }
808 m->m_flags |= (m0->m_flags & M_MCAST);
809 /*
810 * In the first mbuf, leave room for the link header, then
811 * copy the original IP header including options. The payload
812 * goes into an additional mbuf chain returned by m_copym().
813 */
814 m->m_data += max_linkhdr;
815 mhip = mtod(m, struct ip *);
816 *mhip = *ip;
817 if (hlen > sizeof (struct ip)) {
818 mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
819 mhip->ip_v = IPVERSION;
820 mhip->ip_hl = mhlen >> 2;
821 }
822 m->m_len = mhlen;
823 /* XXX do we need to add ip_off below ? */
824 mhip->ip_off = ((off - hlen) >> 3) + ip_off;
825 if (off + len >= ip_len)
826 len = ip_len - off;
827 else
828 mhip->ip_off |= IP_MF;
829 mhip->ip_len = htons((u_short)(len + mhlen));
830 m->m_next = m_copym(m0, off, len, M_NOWAIT);
831 if (m->m_next == NULL) { /* copy failed */
832 m_free(m);
833 error = ENOBUFS; /* ??? */
834 IPSTAT_INC(ips_odropped);
835 goto done;
836 }
837 m->m_pkthdr.len = mhlen + len;
838 m->m_pkthdr.rcvif = NULL;
839#ifdef MAC
840 mac_netinet_fragment(m0, m);
841#endif
842 m->m_pkthdr.csum_flags = m0->m_pkthdr.csum_flags;
843 mhip->ip_off = htons(mhip->ip_off);
844 mhip->ip_sum = 0;
845 if (m->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
846 mhip->ip_sum = in_cksum(m, mhlen);
847 m->m_pkthdr.csum_flags &= ~CSUM_IP;
848 }
849 *mnext = m;
850 mnext = &m->m_nextpkt;
851 }
852 IPSTAT_ADD(ips_ofragments, nfrags);
853
854 /*
855 * Update first fragment by trimming what's been copied out
856 * and updating header.
857 */
858 m_adj(m0, hlen + firstlen - ip_len);
859 m0->m_pkthdr.len = hlen + firstlen;
860 ip->ip_len = htons((u_short)m0->m_pkthdr.len);
861 ip->ip_off = htons(ip_off | IP_MF);
862 ip->ip_sum = 0;
863 if (m0->m_pkthdr.csum_flags & CSUM_IP & ~if_hwassist_flags) {
864 ip->ip_sum = in_cksum(m0, hlen);
865 m0->m_pkthdr.csum_flags &= ~CSUM_IP;
866 }
867
868done:
869 *m_frag = m0;
870 return error;
871}
872
873void
874in_delayed_cksum(struct mbuf *m)
875{
876 struct ip *ip;
877 uint16_t csum, offset, ip_len;
878
879 ip = mtod(m, struct ip *);
880 offset = ip->ip_hl << 2 ;
881 ip_len = ntohs(ip->ip_len);
882 csum = in_cksum_skip(m, ip_len, offset);
883 if (m->m_pkthdr.csum_flags & CSUM_UDP && csum == 0)
884 csum = 0xffff;
885 offset += m->m_pkthdr.csum_data; /* checksum offset */
886
887 if (offset + sizeof(u_short) > m->m_len) {
888 printf("delayed m_pullup, m->len: %d off: %d p: %d\n",
889 m->m_len, offset, ip->ip_p);
890 /*
891 * XXX
892 * this shouldn't happen, but if it does, the
893 * correct behavior may be to insert the checksum
894 * in the appropriate next mbuf in the chain.
895 */
896 return;
897 }
898 *(u_short *)(m->m_data + offset) = csum;
899}
900
901/*
902 * IP socket option processing.
903 */
904int
905ip_ctloutput(struct socket *so, struct sockopt *sopt)
906{
907 struct inpcb *inp = sotoinpcb(so);
908 int error, optval;
909
910 error = optval = 0;
911 if (sopt->sopt_level != IPPROTO_IP) {
912 error = EINVAL;
913
914 if (sopt->sopt_level == SOL_SOCKET &&
915 sopt->sopt_dir == SOPT_SET) {
916 switch (sopt->sopt_name) {
917 case SO_REUSEADDR:
918 INP_WLOCK(inp);
919 if ((so->so_options & SO_REUSEADDR) != 0)
920 inp->inp_flags2 |= INP_REUSEADDR;
921 else
922 inp->inp_flags2 &= ~INP_REUSEADDR;
923 INP_WUNLOCK(inp);
924 error = 0;
925 break;
926 case SO_REUSEPORT:
927 INP_WLOCK(inp);
928 if ((so->so_options & SO_REUSEPORT) != 0)
929 inp->inp_flags2 |= INP_REUSEPORT;
930 else
931 inp->inp_flags2 &= ~INP_REUSEPORT;
932 INP_WUNLOCK(inp);
933 error = 0;
934 break;
935 case SO_SETFIB:
936 INP_WLOCK(inp);
937 inp->inp_inc.inc_fibnum = so->so_fibnum;
938 INP_WUNLOCK(inp);
939 error = 0;
940 break;
941 default:
942 break;
943 }
944 }
945 return (error);
946 }
947
948 switch (sopt->sopt_dir) {
949 case SOPT_SET:
950 switch (sopt->sopt_name) {
951 case IP_OPTIONS:
952#ifdef notyet
953 case IP_RETOPTS:
954#endif
955 {
956 struct mbuf *m;
957 if (sopt->sopt_valsize > MLEN) {
958 error = EMSGSIZE;
959 break;
960 }
961 m = m_get(sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
962 if (m == NULL) {
963 error = ENOBUFS;
964 break;
965 }
966 m->m_len = sopt->sopt_valsize;
967 error = sooptcopyin(sopt, mtod(m, char *), m->m_len,
968 m->m_len);
969 if (error) {
970 m_free(m);
971 break;
972 }
973 INP_WLOCK(inp);
974 error = ip_pcbopts(inp, sopt->sopt_name, m);
975 INP_WUNLOCK(inp);
976 return (error);
977 }
978
979 case IP_BINDANY:
980 if (sopt->sopt_td != NULL) {
981 error = priv_check(sopt->sopt_td,
982 PRIV_NETINET_BINDANY);
983 if (error)
984 break;
985 }
986 /* FALLTHROUGH */
987 case IP_TOS:
988 case IP_TTL:
989 case IP_MINTTL:
990 case IP_RECVOPTS:
991 case IP_RECVRETOPTS:
992 case IP_RECVDSTADDR:
993 case IP_RECVTTL:
994 case IP_RECVIF:
995 case IP_FAITH:
996 case IP_ONESBCAST:
997 case IP_DONTFRAG:
998 case IP_RECVTOS:
999 error = sooptcopyin(sopt, &optval, sizeof optval,
1000 sizeof optval);
1001 if (error)
1002 break;
1003
1004 switch (sopt->sopt_name) {
1005 case IP_TOS:
1006 inp->inp_ip_tos = optval;
1007 break;
1008
1009 case IP_TTL:
1010 inp->inp_ip_ttl = optval;
1011 break;
1012
1013 case IP_MINTTL:
1014 if (optval >= 0 && optval <= MAXTTL)
1015 inp->inp_ip_minttl = optval;
1016 else
1017 error = EINVAL;
1018 break;
1019
1020#define OPTSET(bit) do { \
1021 INP_WLOCK(inp); \
1022 if (optval) \
1023 inp->inp_flags |= bit; \
1024 else \
1025 inp->inp_flags &= ~bit; \
1026 INP_WUNLOCK(inp); \
1027} while (0)
1028
1029 case IP_RECVOPTS:
1030 OPTSET(INP_RECVOPTS);
1031 break;
1032
1033 case IP_RECVRETOPTS:
1034 OPTSET(INP_RECVRETOPTS);
1035 break;
1036
1037 case IP_RECVDSTADDR:
1038 OPTSET(INP_RECVDSTADDR);
1039 break;
1040
1041 case IP_RECVTTL:
1042 OPTSET(INP_RECVTTL);
1043 break;
1044
1045 case IP_RECVIF:
1046 OPTSET(INP_RECVIF);
1047 break;
1048
1049 case IP_FAITH:
1050 OPTSET(INP_FAITH);
1051 break;
1052
1053 case IP_ONESBCAST:
1054 OPTSET(INP_ONESBCAST);
1055 break;
1056 case IP_DONTFRAG:
1057 OPTSET(INP_DONTFRAG);
1058 break;
1059 case IP_BINDANY:
1060 OPTSET(INP_BINDANY);
1061 break;
1062 case IP_RECVTOS:
1063 OPTSET(INP_RECVTOS);
1064 break;
1065 }
1066 break;
1067#undef OPTSET
1068
1069 /*
1070 * Multicast socket options are processed by the in_mcast
1071 * module.
1072 */
1073 case IP_MULTICAST_IF:
1074 case IP_MULTICAST_VIF:
1075 case IP_MULTICAST_TTL:
1076 case IP_MULTICAST_LOOP:
1077 case IP_ADD_MEMBERSHIP:
1078 case IP_DROP_MEMBERSHIP:
1079 case IP_ADD_SOURCE_MEMBERSHIP:
1080 case IP_DROP_SOURCE_MEMBERSHIP:
1081 case IP_BLOCK_SOURCE:
1082 case IP_UNBLOCK_SOURCE:
1083 case IP_MSFILTER:
1084 case MCAST_JOIN_GROUP:
1085 case MCAST_LEAVE_GROUP:
1086 case MCAST_JOIN_SOURCE_GROUP:
1087 case MCAST_LEAVE_SOURCE_GROUP:
1088 case MCAST_BLOCK_SOURCE:
1089 case MCAST_UNBLOCK_SOURCE:
1090 error = inp_setmoptions(inp, sopt);
1091 break;
1092
1093 case IP_PORTRANGE:
1094 error = sooptcopyin(sopt, &optval, sizeof optval,
1095 sizeof optval);
1096 if (error)
1097 break;
1098
1099 INP_WLOCK(inp);
1100 switch (optval) {
1101 case IP_PORTRANGE_DEFAULT:
1102 inp->inp_flags &= ~(INP_LOWPORT);
1103 inp->inp_flags &= ~(INP_HIGHPORT);
1104 break;
1105
1106 case IP_PORTRANGE_HIGH:
1107 inp->inp_flags &= ~(INP_LOWPORT);
1108 inp->inp_flags |= INP_HIGHPORT;
1109 break;
1110
1111 case IP_PORTRANGE_LOW:
1112 inp->inp_flags &= ~(INP_HIGHPORT);
1113 inp->inp_flags |= INP_LOWPORT;
1114 break;
1115
1116 default:
1117 error = EINVAL;
1118 break;
1119 }
1120 INP_WUNLOCK(inp);
1121 break;
1122
1123#ifdef IPSEC
1124 case IP_IPSEC_POLICY:
1125 {
1126 caddr_t req;
1127 struct mbuf *m;
1128
1129 if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */
1130 break;
1131 if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */
1132 break;
1133 req = mtod(m, caddr_t);
1134 error = ipsec_set_policy(inp, sopt->sopt_name, req,
1135 m->m_len, (sopt->sopt_td != NULL) ?
1136 sopt->sopt_td->td_ucred : NULL);
1137 m_freem(m);
1138 break;
1139 }
1140#endif /* IPSEC */
1141
1142 default:
1143 error = ENOPROTOOPT;
1144 break;
1145 }
1146 break;
1147
1148 case SOPT_GET:
1149 switch (sopt->sopt_name) {
1150 case IP_OPTIONS:
1151 case IP_RETOPTS:
1152 if (inp->inp_options)
1153 error = sooptcopyout(sopt,
1154 mtod(inp->inp_options,
1155 char *),
1156 inp->inp_options->m_len);
1157 else
1158 sopt->sopt_valsize = 0;
1159 break;
1160
1161 case IP_TOS:
1162 case IP_TTL:
1163 case IP_MINTTL:
1164 case IP_RECVOPTS:
1165 case IP_RECVRETOPTS:
1166 case IP_RECVDSTADDR:
1167 case IP_RECVTTL:
1168 case IP_RECVIF:
1169 case IP_PORTRANGE:
1170 case IP_FAITH:
1171 case IP_ONESBCAST:
1172 case IP_DONTFRAG:
1173 case IP_BINDANY:
1174 case IP_RECVTOS:
1175 switch (sopt->sopt_name) {
1176
1177 case IP_TOS:
1178 optval = inp->inp_ip_tos;
1179 break;
1180
1181 case IP_TTL:
1182 optval = inp->inp_ip_ttl;
1183 break;
1184
1185 case IP_MINTTL:
1186 optval = inp->inp_ip_minttl;
1187 break;
1188
1189#define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
1190
1191 case IP_RECVOPTS:
1192 optval = OPTBIT(INP_RECVOPTS);
1193 break;
1194
1195 case IP_RECVRETOPTS:
1196 optval = OPTBIT(INP_RECVRETOPTS);
1197 break;
1198
1199 case IP_RECVDSTADDR:
1200 optval = OPTBIT(INP_RECVDSTADDR);
1201 break;
1202
1203 case IP_RECVTTL:
1204 optval = OPTBIT(INP_RECVTTL);
1205 break;
1206
1207 case IP_RECVIF:
1208 optval = OPTBIT(INP_RECVIF);
1209 break;
1210
1211 case IP_PORTRANGE:
1212 if (inp->inp_flags & INP_HIGHPORT)
1213 optval = IP_PORTRANGE_HIGH;
1214 else if (inp->inp_flags & INP_LOWPORT)
1215 optval = IP_PORTRANGE_LOW;
1216 else
1217 optval = 0;
1218 break;
1219
1220 case IP_FAITH:
1221 optval = OPTBIT(INP_FAITH);
1222 break;
1223
1224 case IP_ONESBCAST:
1225 optval = OPTBIT(INP_ONESBCAST);
1226 break;
1227 case IP_DONTFRAG:
1228 optval = OPTBIT(INP_DONTFRAG);
1229 break;
1230 case IP_BINDANY:
1231 optval = OPTBIT(INP_BINDANY);
1232 break;
1233 case IP_RECVTOS:
1234 optval = OPTBIT(INP_RECVTOS);
1235 break;
1236 }
1237 error = sooptcopyout(sopt, &optval, sizeof optval);
1238 break;
1239
1240 /*
1241 * Multicast socket options are processed by the in_mcast
1242 * module.
1243 */
1244 case IP_MULTICAST_IF:
1245 case IP_MULTICAST_VIF:
1246 case IP_MULTICAST_TTL:
1247 case IP_MULTICAST_LOOP:
1248 case IP_MSFILTER:
1249 error = inp_getmoptions(inp, sopt);
1250 break;
1251
1252#ifdef IPSEC
1253 case IP_IPSEC_POLICY:
1254 {
1255 struct mbuf *m = NULL;
1256 caddr_t req = NULL;
1257 size_t len = 0;
1258
1259 if (m != 0) {
1260 req = mtod(m, caddr_t);
1261 len = m->m_len;
1262 }
1263 error = ipsec_get_policy(sotoinpcb(so), req, len, &m);
1264 if (error == 0)
1265 error = soopt_mcopyout(sopt, m); /* XXX */
1266 if (error == 0)
1267 m_freem(m);
1268 break;
1269 }
1270#endif /* IPSEC */
1271
1272 default:
1273 error = ENOPROTOOPT;
1274 break;
1275 }
1276 break;
1277 }
1278 return (error);
1279}
1280
1281/*
1282 * Routine called from ip_output() to loop back a copy of an IP multicast
1283 * packet to the input queue of a specified interface. Note that this
1284 * calls the output routine of the loopback "driver", but with an interface
1285 * pointer that might NOT be a loopback interface -- evil, but easier than
1286 * replicating that code here.
1287 */
1288static void
1289ip_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in *dst,
1290 int hlen)
1291{
1292 register struct ip *ip;
1293 struct mbuf *copym;
1294
1295 /*
1296 * Make a deep copy of the packet because we're going to
1297 * modify the pack in order to generate checksums.
1298 */
1299 copym = m_dup(m, M_NOWAIT);
1300 if (copym != NULL && (copym->m_flags & M_EXT || copym->m_len < hlen))
1301 copym = m_pullup(copym, hlen);
1302 if (copym != NULL) {
1303 /* If needed, compute the checksum and mark it as valid. */
1304 if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
1305 in_delayed_cksum(copym);
1306 copym->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
1307 copym->m_pkthdr.csum_flags |=
1308 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1309 copym->m_pkthdr.csum_data = 0xffff;
1310 }
1311 /*
1312 * We don't bother to fragment if the IP length is greater
1313 * than the interface's MTU. Can this possibly matter?
1314 */
1315 ip = mtod(copym, struct ip *);
1316 ip->ip_sum = 0;
1317 ip->ip_sum = in_cksum(copym, hlen);
1318#if 1 /* XXX */
1319 if (dst->sin_family != AF_INET) {
1320 printf("ip_mloopback: bad address family %d\n",
1321 dst->sin_family);
1322 dst->sin_family = AF_INET;
1323 }
1324#endif
1325 if_simloop(ifp, copym, dst->sin_family, 0);
1326 }
1327}
|