1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * The Internet Protocol (IP) output module. 7 * 8 * Version: $Id: ip_output.c,v 1.100 2002/02/01 22:01:03 davem Exp $ 9 * 10 * Authors: Ross Biro 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 * Donald Becker, <becker@super.org> 13 * Alan Cox, <Alan.Cox@linux.org> 14 * Richard Underwood 15 * Stefan Becker, <stefanb@yello.ping.de> 16 * Jorge Cwik, <jorge@laser.satlink.net> 17 * Arnt Gulbrandsen, <agulbra@nvg.unit.no> 18 * Hirokazu Takahashi, <taka@valinux.co.jp> 19 * 20 * See ip_input.c for original log 21 * 22 * Fixes: 23 * Alan Cox : Missing nonblock feature in ip_build_xmit. 24 * Mike Kilburn : htons() missing in ip_build_xmit. 25 * Bradford Johnson: Fix faulty handling of some frames when 26 * no route is found. 27 * Alexander Demenshin: Missing sk/skb free in ip_queue_xmit 28 * (in case if packet not accepted by 29 * output firewall rules) 30 * Mike McLagan : Routing by source 31 * Alexey Kuznetsov: use new route cache 32 * Andi Kleen: Fix broken PMTU recovery and remove 33 * some redundant tests. 34 * Vitaly E. Lavrov : Transparent proxy revived after year coma. 35 * Andi Kleen : Replace ip_reply with ip_send_reply. 36 * Andi Kleen : Split fast and slow ip_build_xmit path 37 * for decreased register pressure on x86 38 * and more readibility. 39 * Marc Boucher : When call_out_firewall returns FW_QUEUE, 40 * silently drop skb instead of failing with -EPERM. 41 * Detlev Wengorz : Copy protocol for fragments. 42 * Hirokazu Takahashi: HW checksumming for outgoing UDP 43 * datagrams. 44 * Hirokazu Takahashi: sendfile() on UDP works now. 45 */ 46 47 #include <asm/uaccess.h> 48 #include <asm/system.h> 49 #include <linux/module.h> 50 #include <linux/types.h> 51 #include <linux/kernel.h> 52 #include <linux/mm.h> 53 #include <linux/string.h> 54 #include <linux/errno.h> 55 #include <linux/highmem.h> 56 57 #include <linux/socket.h> 58 #include <linux/sockios.h> 59 #include <linux/in.h> 60 #include <linux/inet.h> 61 #include <linux/netdevice.h> 62 #include <linux/etherdevice.h> 63 #include <linux/proc_fs.h> 64 #include <linux/stat.h> 65 #include <linux/init.h> 66 67 #include <net/snmp.h> 68 #include <net/ip.h> 69 #include <net/protocol.h> 70 #include <net/route.h> 71 #include <net/xfrm.h> 72 #include <linux/skbuff.h> 73 #include <net/sock.h> 74 #include <net/arp.h> 75 #include <net/icmp.h> 76 #include <net/checksum.h> 77 #include <net/inetpeer.h> 78 #include <net/checksum.h> 79 #include <linux/igmp.h> 80 #include <linux/netfilter_ipv4.h> 81 #include <linux/netfilter_bridge.h> 82 #include <linux/mroute.h> 83 #include <linux/netlink.h> 84 #include <linux/tcp.h> 85 86 int sysctl_ip_default_ttl __read_mostly = IPDEFTTL; 87 88 /* Generate a checksum for an outgoing IP datagram. */ 89 __inline__ void ip_send_check(struct iphdr *iph) 90 { 91 iph->check = 0; 92 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl); 93 } 94 95 /* dev_loopback_xmit for use with netfilter. */ 96 static int ip_dev_loopback_xmit(struct sk_buff *newskb) 97 { 98 skb_reset_mac_header(newskb); 99 __skb_pull(newskb, skb_network_offset(newskb)); 100 newskb->pkt_type = PACKET_LOOPBACK; 101 newskb->ip_summed = CHECKSUM_UNNECESSARY; 102 BUG_TRAP(newskb->dst); 103 netif_rx(newskb); 104 return 0; 105 } 106 107 static inline int ip_select_ttl(struct inet_sock *inet, struct dst_entry *dst) 108 { 109 int ttl = inet->uc_ttl; 110 111 if (ttl < 0) 112 ttl = dst_metric(dst, RTAX_HOPLIMIT); 113 return ttl; 114 } 115 116 /* 117 * Add an ip header to a skbuff and send it out. 118 * 119 */ 120 int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk, 121 __be32 saddr, __be32 daddr, struct ip_options *opt) 122 { 123 struct inet_sock *inet = inet_sk(sk); 124 struct rtable *rt = (struct rtable *)skb->dst; 125 struct iphdr *iph; 126 127 /* Build the IP header. */ 128 skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0)); 129 skb_reset_network_header(skb); 130 iph = ip_hdr(skb); 131 iph->version = 4; 132 iph->ihl = 5; 133 iph->tos = inet->tos; 134 if (ip_dont_fragment(sk, &rt->u.dst)) 135 iph->frag_off = htons(IP_DF); 136 else 137 iph->frag_off = 0; 138 iph->ttl = ip_select_ttl(inet, &rt->u.dst); 139 iph->daddr = rt->rt_dst; 140 iph->saddr = rt->rt_src; 141 iph->protocol = sk->sk_protocol; 142 iph->tot_len = htons(skb->len); 143 ip_select_ident(iph, &rt->u.dst, sk); 144 145 if (opt && opt->optlen) { 146 iph->ihl += opt->optlen>>2; 147 ip_options_build(skb, opt, daddr, rt, 0); 148 } 149 ip_send_check(iph); 150 151 skb->priority = sk->sk_priority; 152 153 /* Send it out. */ 154 return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev, 155 dst_output); 156 } 157 158 EXPORT_SYMBOL_GPL(ip_build_and_send_pkt); 159 160 static inline int ip_finish_output2(struct sk_buff *skb) 161 { 162 struct dst_entry *dst = skb->dst; 163 struct rtable *rt = (struct rtable *)dst; 164 struct net_device *dev = dst->dev; 165 int hh_len = LL_RESERVED_SPACE(dev); 166 167 if (rt->rt_type == RTN_MULTICAST) 168 IP_INC_STATS(IPSTATS_MIB_OUTMCASTPKTS); 169 else if (rt->rt_type == RTN_BROADCAST) 170 IP_INC_STATS(IPSTATS_MIB_OUTBCASTPKTS); 171 172 /* Be paranoid, rather than too clever. */ 173 if (unlikely(skb_headroom(skb) < hh_len && dev->hard_header)) { 174 struct sk_buff *skb2; 175 176 skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev)); 177 if (skb2 == NULL) { 178 kfree_skb(skb); 179 return -ENOMEM; 180 } 181 if (skb->sk) 182 skb_set_owner_w(skb2, skb->sk); 183 kfree_skb(skb); 184 skb = skb2; 185 } 186 187 if (dst->hh) 188 return neigh_hh_output(dst->hh, skb); 189 else if (dst->neighbour) 190 return dst->neighbour->output(skb); 191 192 if (net_ratelimit()) 193 printk(KERN_DEBUG "ip_finish_output2: No header cache and no neighbour!\n"); 194 kfree_skb(skb); 195 return -EINVAL; 196 } 197 198 static inline int ip_skb_dst_mtu(struct sk_buff *skb) 199 { 200 struct inet_sock *inet = skb->sk ? inet_sk(skb->sk) : NULL; 201 202 return (inet && inet->pmtudisc == IP_PMTUDISC_PROBE) ? 203 skb->dst->dev->mtu : dst_mtu(skb->dst); 204 } 205 206 static inline int ip_finish_output(struct sk_buff *skb) 207 { 208 #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM) 209 /* Policy lookup after SNAT yielded a new policy */ 210 if (skb->dst->xfrm != NULL) { 211 IPCB(skb)->flags |= IPSKB_REROUTED; 212 return dst_output(skb); 213 } 214 #endif 215 if (skb->len > ip_skb_dst_mtu(skb) && !skb_is_gso(skb)) 216 return ip_fragment(skb, ip_finish_output2); 217 else 218 return ip_finish_output2(skb); 219 } 220 221 int ip_mc_output(struct sk_buff *skb) 222 { 223 struct sock *sk = skb->sk; 224 struct rtable *rt = (struct rtable*)skb->dst; 225 struct net_device *dev = rt->u.dst.dev; 226 227 /* 228 * If the indicated interface is up and running, send the packet. 229 */ 230 IP_INC_STATS(IPSTATS_MIB_OUTREQUESTS); 231 232 skb->dev = dev; 233 skb->protocol = htons(ETH_P_IP); 234 235 /* 236 * Multicasts are looped back for other local users 237 */ 238 239 if (rt->rt_flags&RTCF_MULTICAST) { 240 if ((!sk || inet_sk(sk)->mc_loop) 241 #ifdef CONFIG_IP_MROUTE 242 /* Small optimization: do not loopback not local frames, 243 which returned after forwarding; they will be dropped 244 by ip_mr_input in any case. 245 Note, that local frames are looped back to be delivered 246 to local recipients. 247 248 This check is duplicated in ip_mr_input at the moment. 249 */ 250 && ((rt->rt_flags&RTCF_LOCAL) || !(IPCB(skb)->flags&IPSKB_FORWARDED)) 251 #endif 252 ) { 253 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC); 254 if (newskb) 255 NF_HOOK(PF_INET, NF_IP_POST_ROUTING, newskb, NULL, 256 newskb->dev, 257 ip_dev_loopback_xmit); 258 } 259 260 /* Multicasts with ttl 0 must not go beyond the host */ 261 262 if (ip_hdr(skb)->ttl == 0) { 263 kfree_skb(skb); 264 return 0; 265 } 266 } 267 268 if (rt->rt_flags&RTCF_BROADCAST) { 269 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC); 270 if (newskb) 271 NF_HOOK(PF_INET, NF_IP_POST_ROUTING, newskb, NULL, 272 newskb->dev, ip_dev_loopback_xmit); 273 } 274 275 return NF_HOOK_COND(PF_INET, NF_IP_POST_ROUTING, skb, NULL, skb->dev, 276 ip_finish_output, 277 !(IPCB(skb)->flags & IPSKB_REROUTED)); 278 } 279 280 int ip_output(struct sk_buff *skb) 281 { 282 struct net_device *dev = skb->dst->dev; 283 284 IP_INC_STATS(IPSTATS_MIB_OUTREQUESTS); 285 286 skb->dev = dev; 287 skb->protocol = htons(ETH_P_IP); 288 289 return NF_HOOK_COND(PF_INET, NF_IP_POST_ROUTING, skb, NULL, dev, 290 ip_finish_output, 291 !(IPCB(skb)->flags & IPSKB_REROUTED)); 292 } 293 294 int ip_queue_xmit(struct sk_buff *skb, int ipfragok) 295 { 296 struct sock *sk = skb->sk; 297 struct inet_sock *inet = inet_sk(sk); 298 struct ip_options *opt = inet->opt; 299 struct rtable *rt; 300 struct iphdr *iph; 301 302 /* Skip all of this if the packet is already routed, 303 * f.e. by something like SCTP. 304 */ 305 rt = (struct rtable *) skb->dst; 306 if (rt != NULL) 307 goto packet_routed; 308 309 /* Make sure we can route this packet. */ 310 rt = (struct rtable *)__sk_dst_check(sk, 0); 311 if (rt == NULL) { 312 __be32 daddr; 313 314 /* Use correct destination address if we have options. */ 315 daddr = inet->daddr; 316 if(opt && opt->srr) 317 daddr = opt->faddr; 318 319 { 320 struct flowi fl = { .oif = sk->sk_bound_dev_if, 321 .nl_u = { .ip4_u = 322 { .daddr = daddr, 323 .saddr = inet->saddr, 324 .tos = RT_CONN_FLAGS(sk) } }, 325 .proto = sk->sk_protocol, 326 .uli_u = { .ports = 327 { .sport = inet->sport, 328 .dport = inet->dport } } }; 329 330 /* If this fails, retransmit mechanism of transport layer will 331 * keep trying until route appears or the connection times 332 * itself out. 333 */ 334 security_sk_classify_flow(sk, &fl); 335 if (ip_route_output_flow(&rt, &fl, sk, 0)) 336 goto no_route; 337 } 338 sk_setup_caps(sk, &rt->u.dst); 339 } 340 skb->dst = dst_clone(&rt->u.dst); 341 342 packet_routed: 343 if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway) 344 goto no_route; 345 346 /* OK, we know where to send it, allocate and build IP header. */ 347 skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0)); 348 skb_reset_network_header(skb); 349 iph = ip_hdr(skb); 350 *((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff)); 351 iph->tot_len = htons(skb->len); 352 if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok) 353 iph->frag_off = htons(IP_DF); 354 else 355 iph->frag_off = 0; 356 iph->ttl = ip_select_ttl(inet, &rt->u.dst); 357 iph->protocol = sk->sk_protocol; 358 iph->saddr = rt->rt_src; 359 iph->daddr = rt->rt_dst; 360 /* Transport layer set skb->h.foo itself. */ 361 362 if (opt && opt->optlen) { 363 iph->ihl += opt->optlen >> 2; 364 ip_options_build(skb, opt, inet->daddr, rt, 0); 365 } 366 367 ip_select_ident_more(iph, &rt->u.dst, sk, 368 (skb_shinfo(skb)->gso_segs ?: 1) - 1); 369 370 /* Add an IP checksum. */ 371 ip_send_check(iph); 372 373 skb->priority = sk->sk_priority; 374 375 return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev, 376 dst_output); 377 378 no_route: 379 IP_INC_STATS(IPSTATS_MIB_OUTNOROUTES); 380 kfree_skb(skb); 381 return -EHOSTUNREACH; 382 } 383 384 385 static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from) 386 { 387 to->pkt_type = from->pkt_type; 388 to->priority = from->priority; 389 to->protocol = from->protocol; 390 dst_release(to->dst); 391 to->dst = dst_clone(from->dst); 392 to->dev = from->dev; 393 to->mark = from->mark; 394 395 /* Copy the flags to each fragment. */ 396 IPCB(to)->flags = IPCB(from)->flags; 397 398 #ifdef CONFIG_NET_SCHED 399 to->tc_index = from->tc_index; 400 #endif 401 nf_copy(to, from); 402 #if defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE) 403 to->ipvs_property = from->ipvs_property; 404 #endif 405 skb_copy_secmark(to, from); 406 } 407 408 /* 409 * This IP datagram is too large to be sent in one piece. Break it up into 410 * smaller pieces (each of size equal to IP header plus 411 * a block of the data of the original IP data part) that will yet fit in a 412 * single device frame, and queue such a frame for sending. 413 */ 414 415 int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*)) 416 { 417 struct iphdr *iph; 418 int raw = 0; 419 int ptr; 420 struct net_device *dev; 421 struct sk_buff *skb2; 422 unsigned int mtu, hlen, left, len, ll_rs, pad; 423 int offset; 424 __be16 not_last_frag; 425 struct rtable *rt = (struct rtable*)skb->dst; 426 int err = 0; 427 428 dev = rt->u.dst.dev; 429 430 /* 431 * Point into the IP datagram header. 432 */ 433 434 iph = ip_hdr(skb); 435 436 if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) { 437 IP_INC_STATS(IPSTATS_MIB_FRAGFAILS); 438 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, 439 htonl(ip_skb_dst_mtu(skb))); 440 kfree_skb(skb); 441 return -EMSGSIZE; 442 } 443 444 /* 445 * Setup starting values. 446 */ 447 448 hlen = iph->ihl * 4; 449 mtu = dst_mtu(&rt->u.dst) - hlen; /* Size of data space */ 450 IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE; 451 452 /* When frag_list is given, use it. First, check its validity: 453 * some transformers could create wrong frag_list or break existing 454 * one, it is not prohibited. In this case fall back to copying. 455 * 456 * LATER: this step can be merged to real generation of fragments, 457 * we can switch to copy when see the first bad fragment. 458 */ 459 if (skb_shinfo(skb)->frag_list) { 460 struct sk_buff *frag; 461 int first_len = skb_pagelen(skb); 462 463 if (first_len - hlen > mtu || 464 ((first_len - hlen) & 7) || 465 (iph->frag_off & htons(IP_MF|IP_OFFSET)) || 466 skb_cloned(skb)) 467 goto slow_path; 468 469 for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) { 470 /* Correct geometry. */ 471 if (frag->len > mtu || 472 ((frag->len & 7) && frag->next) || 473 skb_headroom(frag) < hlen) 474 goto slow_path; 475 476 /* Partially cloned skb? */ 477 if (skb_shared(frag)) 478 goto slow_path; 479 480 BUG_ON(frag->sk); 481 if (skb->sk) { 482 sock_hold(skb->sk); 483 frag->sk = skb->sk; 484 frag->destructor = sock_wfree; 485 skb->truesize -= frag->truesize; 486 } 487 } 488 489 /* Everything is OK. Generate! */ 490 491 err = 0; 492 offset = 0; 493 frag = skb_shinfo(skb)->frag_list; 494 skb_shinfo(skb)->frag_list = NULL; 495 skb->data_len = first_len - skb_headlen(skb); 496 skb->len = first_len; 497 iph->tot_len = htons(first_len); 498 iph->frag_off = htons(IP_MF); 499 ip_send_check(iph); 500 501 for (;;) { 502 /* Prepare header of the next frame, 503 * before previous one went down. */ 504 if (frag) { 505 frag->ip_summed = CHECKSUM_NONE; 506 skb_reset_transport_header(frag); 507 __skb_push(frag, hlen); 508 skb_reset_network_header(frag); 509 memcpy(skb_network_header(frag), iph, hlen); 510 iph = ip_hdr(frag); 511 iph->tot_len = htons(frag->len); 512 ip_copy_metadata(frag, skb); 513 if (offset == 0) 514 ip_options_fragment(frag); 515 offset += skb->len - hlen; 516 iph->frag_off = htons(offset>>3); 517 if (frag->next != NULL) 518 iph->frag_off |= htons(IP_MF); 519 /* Ready, complete checksum */ 520 ip_send_check(iph); 521 } 522 523 err = output(skb); 524 525 if (!err) 526 IP_INC_STATS(IPSTATS_MIB_FRAGCREATES); 527 if (err || !frag) 528 break; 529 530 skb = frag; 531 frag = skb->next; 532 skb->next = NULL; 533 } 534 535 if (err == 0) { 536 IP_INC_STATS(IPSTATS_MIB_FRAGOKS); 537 return 0; 538 } 539 540 while (frag) { 541 skb = frag->next; 542 kfree_skb(frag); 543 frag = skb; 544 } 545 IP_INC_STATS(IPSTATS_MIB_FRAGFAILS); 546 return err; 547 } 548 549 slow_path: 550 left = skb->len - hlen; /* Space per frame */ 551 ptr = raw + hlen; /* Where to start from */ 552 553 /* for bridged IP traffic encapsulated inside f.e. a vlan header, 554 * we need to make room for the encapsulating header 555 */ 556 pad = nf_bridge_pad(skb); 557 ll_rs = LL_RESERVED_SPACE_EXTRA(rt->u.dst.dev, pad); 558 mtu -= pad; 559 560 /* 561 * Fragment the datagram. 562 */ 563 564 offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3; 565 not_last_frag = iph->frag_off & htons(IP_MF); 566 567 /* 568 * Keep copying data until we run out. 569 */ 570 571 while (left > 0) { 572 len = left; 573 /* IF: it doesn't fit, use 'mtu' - the data space left */ 574 if (len > mtu) 575 len = mtu; 576 /* IF: we are not sending upto and including the packet end 577 then align the next start on an eight byte boundary */ 578 if (len < left) { 579 len &= ~7; 580 } 581 /* 582 * Allocate buffer. 583 */ 584 585 if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) { 586 NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n"); 587 err = -ENOMEM; 588 goto fail; 589 } 590 591 /* 592 * Set up data on packet 593 */ 594 595 ip_copy_metadata(skb2, skb); 596 skb_reserve(skb2, ll_rs); 597 skb_put(skb2, len + hlen); 598 skb_reset_network_header(skb2); 599 skb2->transport_header = skb2->network_header + hlen; 600 601 /* 602 * Charge the memory for the fragment to any owner 603 * it might possess 604 */ 605 606 if (skb->sk) 607 skb_set_owner_w(skb2, skb->sk); 608 609 /* 610 * Copy the packet header into the new buffer. 611 */ 612 613 skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen); 614 615 /* 616 * Copy a block of the IP datagram. 617 */ 618 if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len)) 619 BUG(); 620 left -= len; 621 622 /* 623 * Fill in the new header fields. 624 */ 625 iph = ip_hdr(skb2); 626 iph->frag_off = htons((offset >> 3)); 627 628 /* ANK: dirty, but effective trick. Upgrade options only if 629 * the segment to be fragmented was THE FIRST (otherwise, 630 * options are already fixed) and make it ONCE 631 * on the initial skb, so that all the following fragments 632 * will inherit fixed options. 633 */ 634 if (offset == 0) 635 ip_options_fragment(skb); 636 637 /* 638 * Added AC : If we are fragmenting a fragment that's not the 639 * last fragment then keep MF on each bit 640 */ 641 if (left > 0 || not_last_frag) 642 iph->frag_off |= htons(IP_MF); 643 ptr += len; 644 offset += len; 645 646 /* 647 * Put this fragment into the sending queue. 648 */ 649 iph->tot_len = htons(len + hlen); 650 651 ip_send_check(iph); 652 653 err = output(skb2); 654 if (err) 655 goto fail; 656 657 IP_INC_STATS(IPSTATS_MIB_FRAGCREATES); 658 } 659 kfree_skb(skb); 660 IP_INC_STATS(IPSTATS_MIB_FRAGOKS); 661 return err; 662 663 fail: 664 kfree_skb(skb); 665 IP_INC_STATS(IPSTATS_MIB_FRAGFAILS); 666 return err; 667 } 668 669 EXPORT_SYMBOL(ip_fragment); 670 671 int 672 ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb) 673 { 674 struct iovec *iov = from; 675 676 if (skb->ip_summed == CHECKSUM_PARTIAL) { 677 if (memcpy_fromiovecend(to, iov, offset, len) < 0) 678 return -EFAULT; 679 } else { 680 __wsum csum = 0; 681 if (csum_partial_copy_fromiovecend(to, iov, offset, len, &csum) < 0) 682 return -EFAULT; 683 skb->csum = csum_block_add(skb->csum, csum, odd); 684 } 685 return 0; 686 } 687 688 static inline __wsum 689 csum_page(struct page *page, int offset, int copy) 690 { 691 char *kaddr; 692 __wsum csum; 693 kaddr = kmap(page); 694 csum = csum_partial(kaddr + offset, copy, 0); 695 kunmap(page); 696 return csum; 697 } 698 699 static inline int ip_ufo_append_data(struct sock *sk, 700 int getfrag(void *from, char *to, int offset, int len, 701 int odd, struct sk_buff *skb), 702 void *from, int length, int hh_len, int fragheaderlen, 703 int transhdrlen, int mtu,unsigned int flags) 704 { 705 struct sk_buff *skb; 706 int err; 707 708 /* There is support for UDP fragmentation offload by network 709 * device, so create one single skb packet containing complete 710 * udp datagram 711 */ 712 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) { 713 skb = sock_alloc_send_skb(sk, 714 hh_len + fragheaderlen + transhdrlen + 20, 715 (flags & MSG_DONTWAIT), &err); 716 717 if (skb == NULL) 718 return err; 719 720 /* reserve space for Hardware header */ 721 skb_reserve(skb, hh_len); 722 723 /* create space for UDP/IP header */ 724 skb_put(skb,fragheaderlen + transhdrlen); 725 726 /* initialize network header pointer */ 727 skb_reset_network_header(skb); 728 729 /* initialize protocol header pointer */ 730 skb->transport_header = skb->network_header + fragheaderlen; 731 732 skb->ip_summed = CHECKSUM_PARTIAL; 733 skb->csum = 0; 734 sk->sk_sndmsg_off = 0; 735 } 736 737 err = skb_append_datato_frags(sk,skb, getfrag, from, 738 (length - transhdrlen)); 739 if (!err) { 740 /* specify the length of each IP datagram fragment*/ 741 skb_shinfo(skb)->gso_size = mtu - fragheaderlen; 742 skb_shinfo(skb)->gso_type = SKB_GSO_UDP; 743 __skb_queue_tail(&sk->sk_write_queue, skb); 744 745 return 0; 746 } 747 /* There is not enough support do UFO , 748 * so follow normal path 749 */ 750 kfree_skb(skb); 751 return err; 752 } 753 754 /* 755 * ip_append_data() and ip_append_page() can make one large IP datagram 756 * from many pieces of data. Each pieces will be holded on the socket 757 * until ip_push_pending_frames() is called. Each piece can be a page 758 * or non-page data. 759 * 760 * Not only UDP, other transport protocols - e.g. raw sockets - can use 761 * this interface potentially. 762 * 763 * LATER: length must be adjusted by pad at tail, when it is required. 764 */ 765 int ip_append_data(struct sock *sk, 766 int getfrag(void *from, char *to, int offset, int len, 767 int odd, struct sk_buff *skb), 768 void *from, int length, int transhdrlen, 769 struct ipcm_cookie *ipc, struct rtable *rt, 770 unsigned int flags) 771 { 772 struct inet_sock *inet = inet_sk(sk); 773 struct sk_buff *skb; 774 775 struct ip_options *opt = NULL; 776 int hh_len; 777 int exthdrlen; 778 int mtu; 779 int copy; 780 int err; 781 int offset = 0; 782 unsigned int maxfraglen, fragheaderlen; 783 int csummode = CHECKSUM_NONE; 784 785 if (flags&MSG_PROBE) 786 return 0; 787 788 if (skb_queue_empty(&sk->sk_write_queue)) { 789 /* 790 * setup for corking. 791 */ 792 opt = ipc->opt; 793 if (opt) { 794 if (inet->cork.opt == NULL) { 795 inet->cork.opt = kmalloc(sizeof(struct ip_options) + 40, sk->sk_allocation); 796 if (unlikely(inet->cork.opt == NULL)) 797 return -ENOBUFS; 798 } 799 memcpy(inet->cork.opt, opt, sizeof(struct ip_options)+opt->optlen); 800 inet->cork.flags |= IPCORK_OPT; 801 inet->cork.addr = ipc->addr; 802 } 803 dst_hold(&rt->u.dst); 804 inet->cork.fragsize = mtu = inet->pmtudisc == IP_PMTUDISC_PROBE ? 805 rt->u.dst.dev->mtu : 806 dst_mtu(rt->u.dst.path); 807 inet->cork.rt = rt; 808 inet->cork.length = 0; 809 sk->sk_sndmsg_page = NULL; 810 sk->sk_sndmsg_off = 0; 811 if ((exthdrlen = rt->u.dst.header_len) != 0) { 812 length += exthdrlen; 813 transhdrlen += exthdrlen; 814 } 815 } else { 816 rt = inet->cork.rt; 817 if (inet->cork.flags & IPCORK_OPT) 818 opt = inet->cork.opt; 819 820 transhdrlen = 0; 821 exthdrlen = 0; 822 mtu = inet->cork.fragsize; 823 } 824 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev); 825 826 fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0); 827 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen; 828 829 if (inet->cork.length + length > 0xFFFF - fragheaderlen) { 830 ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu-exthdrlen); 831 return -EMSGSIZE; 832 } 833 834 /* 835 * transhdrlen > 0 means that this is the first fragment and we wish 836 * it won't be fragmented in the future. 837 */ 838 if (transhdrlen && 839 length + fragheaderlen <= mtu && 840 rt->u.dst.dev->features & NETIF_F_ALL_CSUM && 841 !exthdrlen) 842 csummode = CHECKSUM_PARTIAL; 843 844 inet->cork.length += length; 845 if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) && 846 (rt->u.dst.dev->features & NETIF_F_UFO)) { 847 848 err = ip_ufo_append_data(sk, getfrag, from, length, hh_len, 849 fragheaderlen, transhdrlen, mtu, 850 flags); 851 if (err) 852 goto error; 853 return 0; 854 } 855 856 /* So, what's going on in the loop below? 857 * 858 * We use calculated fragment length to generate chained skb, 859 * each of segments is IP fragment ready for sending to network after 860 * adding appropriate IP header. 861 */ 862 863 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) 864 goto alloc_new_skb; 865 866 while (length > 0) { 867 /* Check if the remaining data fits into current packet. */ 868 copy = mtu - skb->len; 869 if (copy < length) 870 copy = maxfraglen - skb->len; 871 if (copy <= 0) { 872 char *data; 873 unsigned int datalen; 874 unsigned int fraglen; 875 unsigned int fraggap; 876 unsigned int alloclen; 877 struct sk_buff *skb_prev; 878 alloc_new_skb: 879 skb_prev = skb; 880 if (skb_prev) 881 fraggap = skb_prev->len - maxfraglen; 882 else 883 fraggap = 0; 884 885 /* 886 * If remaining data exceeds the mtu, 887 * we know we need more fragment(s). 888 */ 889 datalen = length + fraggap; 890 if (datalen > mtu - fragheaderlen) 891 datalen = maxfraglen - fragheaderlen; 892 fraglen = datalen + fragheaderlen; 893 894 if ((flags & MSG_MORE) && 895 !(rt->u.dst.dev->features&NETIF_F_SG)) 896 alloclen = mtu; 897 else 898 alloclen = datalen + fragheaderlen; 899 900 /* The last fragment gets additional space at tail. 901 * Note, with MSG_MORE we overallocate on fragments, 902 * because we have no idea what fragment will be 903 * the last. 904 */ 905 if (datalen == length + fraggap) 906 alloclen += rt->u.dst.trailer_len; 907 908 if (transhdrlen) { 909 skb = sock_alloc_send_skb(sk, 910 alloclen + hh_len + 15, 911 (flags & MSG_DONTWAIT), &err); 912 } else { 913 skb = NULL; 914 if (atomic_read(&sk->sk_wmem_alloc) <= 915 2 * sk->sk_sndbuf) 916 skb = sock_wmalloc(sk, 917 alloclen + hh_len + 15, 1, 918 sk->sk_allocation); 919 if (unlikely(skb == NULL)) 920 err = -ENOBUFS; 921 } 922 if (skb == NULL) 923 goto error; 924 925 /* 926 * Fill in the control structures 927 */ 928 skb->ip_summed = csummode; 929 skb->csum = 0; 930 skb_reserve(skb, hh_len); 931 932 /* 933 * Find where to start putting bytes. 934 */ 935 data = skb_put(skb, fraglen); 936 skb_set_network_header(skb, exthdrlen); 937 skb->transport_header = (skb->network_header + 938 fragheaderlen); 939 data += fragheaderlen; 940 941 if (fraggap) { 942 skb->csum = skb_copy_and_csum_bits( 943 skb_prev, maxfraglen, 944 data + transhdrlen, fraggap, 0); 945 skb_prev->csum = csum_sub(skb_prev->csum, 946 skb->csum); 947 data += fraggap; 948 pskb_trim_unique(skb_prev, maxfraglen); 949 } 950 951 copy = datalen - transhdrlen - fraggap; 952 if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) { 953 err = -EFAULT; 954 kfree_skb(skb); 955 goto error; 956 } 957 958 offset += copy; 959 length -= datalen - fraggap; 960 transhdrlen = 0; 961 exthdrlen = 0; 962 csummode = CHECKSUM_NONE; 963 964 /* 965 * Put the packet on the pending queue. 966 */ 967 __skb_queue_tail(&sk->sk_write_queue, skb); 968 continue; 969 } 970 971 if (copy > length) 972 copy = length; 973 974 if (!(rt->u.dst.dev->features&NETIF_F_SG)) { 975 unsigned int off; 976 977 off = skb->len; 978 if (getfrag(from, skb_put(skb, copy), 979 offset, copy, off, skb) < 0) { 980 __skb_trim(skb, off); 981 err = -EFAULT; 982 goto error; 983 } 984 } else { 985 int i = skb_shinfo(skb)->nr_frags; 986 skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1]; 987 struct page *page = sk->sk_sndmsg_page; 988 int off = sk->sk_sndmsg_off; 989 unsigned int left; 990 991 if (page && (left = PAGE_SIZE - off) > 0) { 992 if (copy >= left) 993 copy = left; 994 if (page != frag->page) { 995 if (i == MAX_SKB_FRAGS) { 996 err = -EMSGSIZE; 997 goto error; 998 } 999 get_page(page); 1000 skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0); 1001 frag = &skb_shinfo(skb)->frags[i]; 1002 } 1003 } else if (i < MAX_SKB_FRAGS) { 1004 if (copy > PAGE_SIZE) 1005 copy = PAGE_SIZE; 1006 page = alloc_pages(sk->sk_allocation, 0); 1007 if (page == NULL) { 1008 err = -ENOMEM; 1009 goto error; 1010 } 1011 sk->sk_sndmsg_page = page; 1012 sk->sk_sndmsg_off = 0; 1013 1014 skb_fill_page_desc(skb, i, page, 0, 0); 1015 frag = &skb_shinfo(skb)->frags[i]; 1016 skb->truesize += PAGE_SIZE; 1017 atomic_add(PAGE_SIZE, &sk->sk_wmem_alloc); 1018 } else { 1019 err = -EMSGSIZE; 1020 goto error; 1021 } 1022 if (getfrag(from, page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) { 1023 err = -EFAULT; 1024 goto error; 1025 } 1026 sk->sk_sndmsg_off += copy; 1027 frag->size += copy; 1028 skb->len += copy; 1029 skb->data_len += copy; 1030 } 1031 offset += copy; 1032 length -= copy; 1033 } 1034 1035 return 0; 1036 1037 error: 1038 inet->cork.length -= length; 1039 IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 1040 return err; 1041 } 1042 1043 ssize_t ip_append_page(struct sock *sk, struct page *page, 1044 int offset, size_t size, int flags) 1045 { 1046 struct inet_sock *inet = inet_sk(sk); 1047 struct sk_buff *skb; 1048 struct rtable *rt; 1049 struct ip_options *opt = NULL; 1050 int hh_len; 1051 int mtu; 1052 int len; 1053 int err; 1054 unsigned int maxfraglen, fragheaderlen, fraggap; 1055 1056 if (inet->hdrincl) 1057 return -EPERM; 1058 1059 if (flags&MSG_PROBE) 1060 return 0; 1061 1062 if (skb_queue_empty(&sk->sk_write_queue)) 1063 return -EINVAL; 1064 1065 rt = inet->cork.rt; 1066 if (inet->cork.flags & IPCORK_OPT) 1067 opt = inet->cork.opt; 1068 1069 if (!(rt->u.dst.dev->features&NETIF_F_SG)) 1070 return -EOPNOTSUPP; 1071 1072 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev); 1073 mtu = inet->cork.fragsize; 1074 1075 fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0); 1076 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen; 1077 1078 if (inet->cork.length + size > 0xFFFF - fragheaderlen) { 1079 ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu); 1080 return -EMSGSIZE; 1081 } 1082 1083 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) 1084 return -EINVAL; 1085 1086 inet->cork.length += size; 1087 if ((sk->sk_protocol == IPPROTO_UDP) && 1088 (rt->u.dst.dev->features & NETIF_F_UFO)) { 1089 skb_shinfo(skb)->gso_size = mtu - fragheaderlen; 1090 skb_shinfo(skb)->gso_type = SKB_GSO_UDP; 1091 } 1092 1093 1094 while (size > 0) { 1095 int i; 1096 1097 if (skb_is_gso(skb)) 1098 len = size; 1099 else { 1100 1101 /* Check if the remaining data fits into current packet. */ 1102 len = mtu - skb->len; 1103 if (len < size) 1104 len = maxfraglen - skb->len; 1105 } 1106 if (len <= 0) { 1107 struct sk_buff *skb_prev; 1108 int alloclen; 1109 1110 skb_prev = skb; 1111 fraggap = skb_prev->len - maxfraglen; 1112 1113 alloclen = fragheaderlen + hh_len + fraggap + 15; 1114 skb = sock_wmalloc(sk, alloclen, 1, sk->sk_allocation); 1115 if (unlikely(!skb)) { 1116 err = -ENOBUFS; 1117 goto error; 1118 } 1119 1120 /* 1121 * Fill in the control structures 1122 */ 1123 skb->ip_summed = CHECKSUM_NONE; 1124 skb->csum = 0; 1125 skb_reserve(skb, hh_len); 1126 1127 /* 1128 * Find where to start putting bytes. 1129 */ 1130 skb_put(skb, fragheaderlen + fraggap); 1131 skb_reset_network_header(skb); 1132 skb->transport_header = (skb->network_header + 1133 fragheaderlen); 1134 if (fraggap) { 1135 skb->csum = skb_copy_and_csum_bits(skb_prev, 1136 maxfraglen, 1137 skb_transport_header(skb), 1138 fraggap, 0); 1139 skb_prev->csum = csum_sub(skb_prev->csum, 1140 skb->csum); 1141 pskb_trim_unique(skb_prev, maxfraglen); 1142 } 1143 1144 /* 1145 * Put the packet on the pending queue. 1146 */ 1147 __skb_queue_tail(&sk->sk_write_queue, skb); 1148 continue; 1149 } 1150 1151 i = skb_shinfo(skb)->nr_frags; 1152 if (len > size) 1153 len = size; 1154 if (skb_can_coalesce(skb, i, page, offset)) { 1155 skb_shinfo(skb)->frags[i-1].size += len; 1156 } else if (i < MAX_SKB_FRAGS) { 1157 get_page(page); 1158 skb_fill_page_desc(skb, i, page, offset, len); 1159 } else { 1160 err = -EMSGSIZE; 1161 goto error; 1162 } 1163 1164 if (skb->ip_summed == CHECKSUM_NONE) { 1165 __wsum csum; 1166 csum = csum_page(page, offset, len); 1167 skb->csum = csum_block_add(skb->csum, csum, skb->len); 1168 } 1169 1170 skb->len += len; 1171 skb->data_len += len; 1172 offset += len; 1173 size -= len; 1174 } 1175 return 0; 1176 1177 error: 1178 inet->cork.length -= size; 1179 IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 1180 return err; 1181 } 1182 1183 /* 1184 * Combined all pending IP fragments on the socket as one IP datagram 1185 * and push them out. 1186 */ 1187 int ip_push_pending_frames(struct sock *sk) 1188 { 1189 struct sk_buff *skb, *tmp_skb; 1190 struct sk_buff **tail_skb; 1191 struct inet_sock *inet = inet_sk(sk); 1192 struct ip_options *opt = NULL; 1193 struct rtable *rt = inet->cork.rt; 1194 struct iphdr *iph; 1195 __be16 df = 0; 1196 __u8 ttl; 1197 int err = 0; 1198 1199 if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL) 1200 goto out; 1201 tail_skb = &(skb_shinfo(skb)->frag_list); 1202 1203 /* move skb->data to ip header from ext header */ 1204 if (skb->data < skb_network_header(skb)) 1205 __skb_pull(skb, skb_network_offset(skb)); 1206 while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) { 1207 __skb_pull(tmp_skb, skb_network_header_len(skb)); 1208 *tail_skb = tmp_skb; 1209 tail_skb = &(tmp_skb->next); 1210 skb->len += tmp_skb->len; 1211 skb->data_len += tmp_skb->len; 1212 skb->truesize += tmp_skb->truesize; 1213 __sock_put(tmp_skb->sk); 1214 tmp_skb->destructor = NULL; 1215 tmp_skb->sk = NULL; 1216 } 1217 1218 /* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow 1219 * to fragment the frame generated here. No matter, what transforms 1220 * how transforms change size of the packet, it will come out. 1221 */ 1222 if (inet->pmtudisc < IP_PMTUDISC_DO) 1223 skb->local_df = 1; 1224 1225 /* DF bit is set when we want to see DF on outgoing frames. 1226 * If local_df is set too, we still allow to fragment this frame 1227 * locally. */ 1228 if (inet->pmtudisc >= IP_PMTUDISC_DO || 1229 (skb->len <= dst_mtu(&rt->u.dst) && 1230 ip_dont_fragment(sk, &rt->u.dst))) 1231 df = htons(IP_DF); 1232 1233 if (inet->cork.flags & IPCORK_OPT) 1234 opt = inet->cork.opt; 1235 1236 if (rt->rt_type == RTN_MULTICAST) 1237 ttl = inet->mc_ttl; 1238 else 1239 ttl = ip_select_ttl(inet, &rt->u.dst); 1240 1241 iph = (struct iphdr *)skb->data; 1242 iph->version = 4; 1243 iph->ihl = 5; 1244 if (opt) { 1245 iph->ihl += opt->optlen>>2; 1246 ip_options_build(skb, opt, inet->cork.addr, rt, 0); 1247 } 1248 iph->tos = inet->tos; 1249 iph->tot_len = htons(skb->len); 1250 iph->frag_off = df; 1251 ip_select_ident(iph, &rt->u.dst, sk); 1252 iph->ttl = ttl; 1253 iph->protocol = sk->sk_protocol; 1254 iph->saddr = rt->rt_src; 1255 iph->daddr = rt->rt_dst; 1256 ip_send_check(iph); 1257 1258 skb->priority = sk->sk_priority; 1259 skb->dst = dst_clone(&rt->u.dst); 1260 1261 /* Netfilter gets whole the not fragmented skb. */ 1262 err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, 1263 skb->dst->dev, dst_output); 1264 if (err) { 1265 if (err > 0) 1266 err = inet->recverr ? net_xmit_errno(err) : 0; 1267 if (err) 1268 goto error; 1269 } 1270 1271 out: 1272 inet->cork.flags &= ~IPCORK_OPT; 1273 kfree(inet->cork.opt); 1274 inet->cork.opt = NULL; 1275 if (inet->cork.rt) { 1276 ip_rt_put(inet->cork.rt); 1277 inet->cork.rt = NULL; 1278 } 1279 return err; 1280 1281 error: 1282 IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 1283 goto out; 1284 } 1285 1286 /* 1287 * Throw away all pending data on the socket. 1288 */ 1289 void ip_flush_pending_frames(struct sock *sk) 1290 { 1291 struct inet_sock *inet = inet_sk(sk); 1292 struct sk_buff *skb; 1293 1294 while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) 1295 kfree_skb(skb); 1296 1297 inet->cork.flags &= ~IPCORK_OPT; 1298 kfree(inet->cork.opt); 1299 inet->cork.opt = NULL; 1300 if (inet->cork.rt) { 1301 ip_rt_put(inet->cork.rt); 1302 inet->cork.rt = NULL; 1303 } 1304 } 1305 1306 1307 /* 1308 * Fetch data from kernel space and fill in checksum if needed. 1309 */ 1310 static int ip_reply_glue_bits(void *dptr, char *to, int offset, 1311 int len, int odd, struct sk_buff *skb) 1312 { 1313 __wsum csum; 1314 1315 csum = csum_partial_copy_nocheck(dptr+offset, to, len, 0); 1316 skb->csum = csum_block_add(skb->csum, csum, odd); 1317 return 0; 1318 } 1319 1320 /* 1321 * Generic function to send a packet as reply to another packet. 1322 * Used to send TCP resets so far. ICMP should use this function too. 1323 * 1324 * Should run single threaded per socket because it uses the sock 1325 * structure to pass arguments. 1326 * 1327 * LATER: switch from ip_build_xmit to ip_append_* 1328 */ 1329 void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg, 1330 unsigned int len) 1331 { 1332 struct inet_sock *inet = inet_sk(sk); 1333 struct { 1334 struct ip_options opt; 1335 char data[40]; 1336 } replyopts; 1337 struct ipcm_cookie ipc; 1338 __be32 daddr; 1339 struct rtable *rt = (struct rtable*)skb->dst; 1340 1341 if (ip_options_echo(&replyopts.opt, skb)) 1342 return; 1343 1344 daddr = ipc.addr = rt->rt_src; 1345 ipc.opt = NULL; 1346 1347 if (replyopts.opt.optlen) { 1348 ipc.opt = &replyopts.opt; 1349 1350 if (ipc.opt->srr) 1351 daddr = replyopts.opt.faddr; 1352 } 1353 1354 { 1355 struct flowi fl = { .oif = arg->bound_dev_if, 1356 .nl_u = { .ip4_u = 1357 { .daddr = daddr, 1358 .saddr = rt->rt_spec_dst, 1359 .tos = RT_TOS(ip_hdr(skb)->tos) } }, 1360 /* Not quite clean, but right. */ 1361 .uli_u = { .ports = 1362 { .sport = tcp_hdr(skb)->dest, 1363 .dport = tcp_hdr(skb)->source } }, 1364 .proto = sk->sk_protocol }; 1365 security_skb_classify_flow(skb, &fl); 1366 if (ip_route_output_key(&rt, &fl)) 1367 return; 1368 } 1369 1370 /* And let IP do all the hard work. 1371 1372 This chunk is not reenterable, hence spinlock. 1373 Note that it uses the fact, that this function is called 1374 with locally disabled BH and that sk cannot be already spinlocked. 1375 */ 1376 bh_lock_sock(sk); 1377 inet->tos = ip_hdr(skb)->tos; 1378 sk->sk_priority = skb->priority; 1379 sk->sk_protocol = ip_hdr(skb)->protocol; 1380 sk->sk_bound_dev_if = arg->bound_dev_if; 1381 ip_append_data(sk, ip_reply_glue_bits, arg->iov->iov_base, len, 0, 1382 &ipc, rt, MSG_DONTWAIT); 1383 if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) { 1384 if (arg->csumoffset >= 0) 1385 *((__sum16 *)skb_transport_header(skb) + 1386 arg->csumoffset) = csum_fold(csum_add(skb->csum, 1387 arg->csum)); 1388 skb->ip_summed = CHECKSUM_NONE; 1389 ip_push_pending_frames(sk); 1390 } 1391 1392 bh_unlock_sock(sk); 1393 1394 ip_rt_put(rt); 1395 } 1396 1397 void __init ip_init(void) 1398 { 1399 ip_rt_init(); 1400 inet_initpeers(); 1401 1402 #if defined(CONFIG_IP_MULTICAST) && defined(CONFIG_PROC_FS) 1403 igmp_mc_proc_init(); 1404 #endif 1405 } 1406 1407 EXPORT_SYMBOL(ip_generic_getfrag); 1408 EXPORT_SYMBOL(ip_queue_xmit); 1409 EXPORT_SYMBOL(ip_send_check); 1410