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