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_NETFILTER_XT_TARGET_TRACE) || \ 403 defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE) 404 to->nf_trace = from->nf_trace; 405 #endif 406 #if defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE) 407 to->ipvs_property = from->ipvs_property; 408 #endif 409 skb_copy_secmark(to, from); 410 } 411 412 /* 413 * This IP datagram is too large to be sent in one piece. Break it up into 414 * smaller pieces (each of size equal to IP header plus 415 * a block of the data of the original IP data part) that will yet fit in a 416 * single device frame, and queue such a frame for sending. 417 */ 418 419 int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*)) 420 { 421 struct iphdr *iph; 422 int raw = 0; 423 int ptr; 424 struct net_device *dev; 425 struct sk_buff *skb2; 426 unsigned int mtu, hlen, left, len, ll_rs, pad; 427 int offset; 428 __be16 not_last_frag; 429 struct rtable *rt = (struct rtable*)skb->dst; 430 int err = 0; 431 432 dev = rt->u.dst.dev; 433 434 /* 435 * Point into the IP datagram header. 436 */ 437 438 iph = ip_hdr(skb); 439 440 if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) { 441 IP_INC_STATS(IPSTATS_MIB_FRAGFAILS); 442 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, 443 htonl(ip_skb_dst_mtu(skb))); 444 kfree_skb(skb); 445 return -EMSGSIZE; 446 } 447 448 /* 449 * Setup starting values. 450 */ 451 452 hlen = iph->ihl * 4; 453 mtu = dst_mtu(&rt->u.dst) - hlen; /* Size of data space */ 454 IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE; 455 456 /* When frag_list is given, use it. First, check its validity: 457 * some transformers could create wrong frag_list or break existing 458 * one, it is not prohibited. In this case fall back to copying. 459 * 460 * LATER: this step can be merged to real generation of fragments, 461 * we can switch to copy when see the first bad fragment. 462 */ 463 if (skb_shinfo(skb)->frag_list) { 464 struct sk_buff *frag; 465 int first_len = skb_pagelen(skb); 466 467 if (first_len - hlen > mtu || 468 ((first_len - hlen) & 7) || 469 (iph->frag_off & htons(IP_MF|IP_OFFSET)) || 470 skb_cloned(skb)) 471 goto slow_path; 472 473 for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) { 474 /* Correct geometry. */ 475 if (frag->len > mtu || 476 ((frag->len & 7) && frag->next) || 477 skb_headroom(frag) < hlen) 478 goto slow_path; 479 480 /* Partially cloned skb? */ 481 if (skb_shared(frag)) 482 goto slow_path; 483 484 BUG_ON(frag->sk); 485 if (skb->sk) { 486 sock_hold(skb->sk); 487 frag->sk = skb->sk; 488 frag->destructor = sock_wfree; 489 skb->truesize -= frag->truesize; 490 } 491 } 492 493 /* Everything is OK. Generate! */ 494 495 err = 0; 496 offset = 0; 497 frag = skb_shinfo(skb)->frag_list; 498 skb_shinfo(skb)->frag_list = NULL; 499 skb->data_len = first_len - skb_headlen(skb); 500 skb->len = first_len; 501 iph->tot_len = htons(first_len); 502 iph->frag_off = htons(IP_MF); 503 ip_send_check(iph); 504 505 for (;;) { 506 /* Prepare header of the next frame, 507 * before previous one went down. */ 508 if (frag) { 509 frag->ip_summed = CHECKSUM_NONE; 510 skb_reset_transport_header(frag); 511 __skb_push(frag, hlen); 512 skb_reset_network_header(frag); 513 memcpy(skb_network_header(frag), iph, hlen); 514 iph = ip_hdr(frag); 515 iph->tot_len = htons(frag->len); 516 ip_copy_metadata(frag, skb); 517 if (offset == 0) 518 ip_options_fragment(frag); 519 offset += skb->len - hlen; 520 iph->frag_off = htons(offset>>3); 521 if (frag->next != NULL) 522 iph->frag_off |= htons(IP_MF); 523 /* Ready, complete checksum */ 524 ip_send_check(iph); 525 } 526 527 err = output(skb); 528 529 if (!err) 530 IP_INC_STATS(IPSTATS_MIB_FRAGCREATES); 531 if (err || !frag) 532 break; 533 534 skb = frag; 535 frag = skb->next; 536 skb->next = NULL; 537 } 538 539 if (err == 0) { 540 IP_INC_STATS(IPSTATS_MIB_FRAGOKS); 541 return 0; 542 } 543 544 while (frag) { 545 skb = frag->next; 546 kfree_skb(frag); 547 frag = skb; 548 } 549 IP_INC_STATS(IPSTATS_MIB_FRAGFAILS); 550 return err; 551 } 552 553 slow_path: 554 left = skb->len - hlen; /* Space per frame */ 555 ptr = raw + hlen; /* Where to start from */ 556 557 /* for bridged IP traffic encapsulated inside f.e. a vlan header, 558 * we need to make room for the encapsulating header 559 */ 560 pad = nf_bridge_pad(skb); 561 ll_rs = LL_RESERVED_SPACE_EXTRA(rt->u.dst.dev, pad); 562 mtu -= pad; 563 564 /* 565 * Fragment the datagram. 566 */ 567 568 offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3; 569 not_last_frag = iph->frag_off & htons(IP_MF); 570 571 /* 572 * Keep copying data until we run out. 573 */ 574 575 while (left > 0) { 576 len = left; 577 /* IF: it doesn't fit, use 'mtu' - the data space left */ 578 if (len > mtu) 579 len = mtu; 580 /* IF: we are not sending upto and including the packet end 581 then align the next start on an eight byte boundary */ 582 if (len < left) { 583 len &= ~7; 584 } 585 /* 586 * Allocate buffer. 587 */ 588 589 if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) { 590 NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n"); 591 err = -ENOMEM; 592 goto fail; 593 } 594 595 /* 596 * Set up data on packet 597 */ 598 599 ip_copy_metadata(skb2, skb); 600 skb_reserve(skb2, ll_rs); 601 skb_put(skb2, len + hlen); 602 skb_reset_network_header(skb2); 603 skb2->transport_header = skb2->network_header + hlen; 604 605 /* 606 * Charge the memory for the fragment to any owner 607 * it might possess 608 */ 609 610 if (skb->sk) 611 skb_set_owner_w(skb2, skb->sk); 612 613 /* 614 * Copy the packet header into the new buffer. 615 */ 616 617 skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen); 618 619 /* 620 * Copy a block of the IP datagram. 621 */ 622 if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len)) 623 BUG(); 624 left -= len; 625 626 /* 627 * Fill in the new header fields. 628 */ 629 iph = ip_hdr(skb2); 630 iph->frag_off = htons((offset >> 3)); 631 632 /* ANK: dirty, but effective trick. Upgrade options only if 633 * the segment to be fragmented was THE FIRST (otherwise, 634 * options are already fixed) and make it ONCE 635 * on the initial skb, so that all the following fragments 636 * will inherit fixed options. 637 */ 638 if (offset == 0) 639 ip_options_fragment(skb); 640 641 /* 642 * Added AC : If we are fragmenting a fragment that's not the 643 * last fragment then keep MF on each bit 644 */ 645 if (left > 0 || not_last_frag) 646 iph->frag_off |= htons(IP_MF); 647 ptr += len; 648 offset += len; 649 650 /* 651 * Put this fragment into the sending queue. 652 */ 653 iph->tot_len = htons(len + hlen); 654 655 ip_send_check(iph); 656 657 err = output(skb2); 658 if (err) 659 goto fail; 660 661 IP_INC_STATS(IPSTATS_MIB_FRAGCREATES); 662 } 663 kfree_skb(skb); 664 IP_INC_STATS(IPSTATS_MIB_FRAGOKS); 665 return err; 666 667 fail: 668 kfree_skb(skb); 669 IP_INC_STATS(IPSTATS_MIB_FRAGFAILS); 670 return err; 671 } 672 673 EXPORT_SYMBOL(ip_fragment); 674 675 int 676 ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb) 677 { 678 struct iovec *iov = from; 679 680 if (skb->ip_summed == CHECKSUM_PARTIAL) { 681 if (memcpy_fromiovecend(to, iov, offset, len) < 0) 682 return -EFAULT; 683 } else { 684 __wsum csum = 0; 685 if (csum_partial_copy_fromiovecend(to, iov, offset, len, &csum) < 0) 686 return -EFAULT; 687 skb->csum = csum_block_add(skb->csum, csum, odd); 688 } 689 return 0; 690 } 691 692 static inline __wsum 693 csum_page(struct page *page, int offset, int copy) 694 { 695 char *kaddr; 696 __wsum csum; 697 kaddr = kmap(page); 698 csum = csum_partial(kaddr + offset, copy, 0); 699 kunmap(page); 700 return csum; 701 } 702 703 static inline int ip_ufo_append_data(struct sock *sk, 704 int getfrag(void *from, char *to, int offset, int len, 705 int odd, struct sk_buff *skb), 706 void *from, int length, int hh_len, int fragheaderlen, 707 int transhdrlen, int mtu,unsigned int flags) 708 { 709 struct sk_buff *skb; 710 int err; 711 712 /* There is support for UDP fragmentation offload by network 713 * device, so create one single skb packet containing complete 714 * udp datagram 715 */ 716 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) { 717 skb = sock_alloc_send_skb(sk, 718 hh_len + fragheaderlen + transhdrlen + 20, 719 (flags & MSG_DONTWAIT), &err); 720 721 if (skb == NULL) 722 return err; 723 724 /* reserve space for Hardware header */ 725 skb_reserve(skb, hh_len); 726 727 /* create space for UDP/IP header */ 728 skb_put(skb,fragheaderlen + transhdrlen); 729 730 /* initialize network header pointer */ 731 skb_reset_network_header(skb); 732 733 /* initialize protocol header pointer */ 734 skb->transport_header = skb->network_header + fragheaderlen; 735 736 skb->ip_summed = CHECKSUM_PARTIAL; 737 skb->csum = 0; 738 sk->sk_sndmsg_off = 0; 739 } 740 741 err = skb_append_datato_frags(sk,skb, getfrag, from, 742 (length - transhdrlen)); 743 if (!err) { 744 /* specify the length of each IP datagram fragment*/ 745 skb_shinfo(skb)->gso_size = mtu - fragheaderlen; 746 skb_shinfo(skb)->gso_type = SKB_GSO_UDP; 747 __skb_queue_tail(&sk->sk_write_queue, skb); 748 749 return 0; 750 } 751 /* There is not enough support do UFO , 752 * so follow normal path 753 */ 754 kfree_skb(skb); 755 return err; 756 } 757 758 /* 759 * ip_append_data() and ip_append_page() can make one large IP datagram 760 * from many pieces of data. Each pieces will be holded on the socket 761 * until ip_push_pending_frames() is called. Each piece can be a page 762 * or non-page data. 763 * 764 * Not only UDP, other transport protocols - e.g. raw sockets - can use 765 * this interface potentially. 766 * 767 * LATER: length must be adjusted by pad at tail, when it is required. 768 */ 769 int ip_append_data(struct sock *sk, 770 int getfrag(void *from, char *to, int offset, int len, 771 int odd, struct sk_buff *skb), 772 void *from, int length, int transhdrlen, 773 struct ipcm_cookie *ipc, struct rtable *rt, 774 unsigned int flags) 775 { 776 struct inet_sock *inet = inet_sk(sk); 777 struct sk_buff *skb; 778 779 struct ip_options *opt = NULL; 780 int hh_len; 781 int exthdrlen; 782 int mtu; 783 int copy; 784 int err; 785 int offset = 0; 786 unsigned int maxfraglen, fragheaderlen; 787 int csummode = CHECKSUM_NONE; 788 789 if (flags&MSG_PROBE) 790 return 0; 791 792 if (skb_queue_empty(&sk->sk_write_queue)) { 793 /* 794 * setup for corking. 795 */ 796 opt = ipc->opt; 797 if (opt) { 798 if (inet->cork.opt == NULL) { 799 inet->cork.opt = kmalloc(sizeof(struct ip_options) + 40, sk->sk_allocation); 800 if (unlikely(inet->cork.opt == NULL)) 801 return -ENOBUFS; 802 } 803 memcpy(inet->cork.opt, opt, sizeof(struct ip_options)+opt->optlen); 804 inet->cork.flags |= IPCORK_OPT; 805 inet->cork.addr = ipc->addr; 806 } 807 dst_hold(&rt->u.dst); 808 inet->cork.fragsize = mtu = inet->pmtudisc == IP_PMTUDISC_PROBE ? 809 rt->u.dst.dev->mtu : 810 dst_mtu(rt->u.dst.path); 811 inet->cork.rt = rt; 812 inet->cork.length = 0; 813 sk->sk_sndmsg_page = NULL; 814 sk->sk_sndmsg_off = 0; 815 if ((exthdrlen = rt->u.dst.header_len) != 0) { 816 length += exthdrlen; 817 transhdrlen += exthdrlen; 818 } 819 } else { 820 rt = inet->cork.rt; 821 if (inet->cork.flags & IPCORK_OPT) 822 opt = inet->cork.opt; 823 824 transhdrlen = 0; 825 exthdrlen = 0; 826 mtu = inet->cork.fragsize; 827 } 828 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev); 829 830 fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0); 831 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen; 832 833 if (inet->cork.length + length > 0xFFFF - fragheaderlen) { 834 ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu-exthdrlen); 835 return -EMSGSIZE; 836 } 837 838 /* 839 * transhdrlen > 0 means that this is the first fragment and we wish 840 * it won't be fragmented in the future. 841 */ 842 if (transhdrlen && 843 length + fragheaderlen <= mtu && 844 rt->u.dst.dev->features & NETIF_F_V4_CSUM && 845 !exthdrlen) 846 csummode = CHECKSUM_PARTIAL; 847 848 inet->cork.length += length; 849 if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) && 850 (rt->u.dst.dev->features & NETIF_F_UFO)) { 851 852 err = ip_ufo_append_data(sk, getfrag, from, length, hh_len, 853 fragheaderlen, transhdrlen, mtu, 854 flags); 855 if (err) 856 goto error; 857 return 0; 858 } 859 860 /* So, what's going on in the loop below? 861 * 862 * We use calculated fragment length to generate chained skb, 863 * each of segments is IP fragment ready for sending to network after 864 * adding appropriate IP header. 865 */ 866 867 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) 868 goto alloc_new_skb; 869 870 while (length > 0) { 871 /* Check if the remaining data fits into current packet. */ 872 copy = mtu - skb->len; 873 if (copy < length) 874 copy = maxfraglen - skb->len; 875 if (copy <= 0) { 876 char *data; 877 unsigned int datalen; 878 unsigned int fraglen; 879 unsigned int fraggap; 880 unsigned int alloclen; 881 struct sk_buff *skb_prev; 882 alloc_new_skb: 883 skb_prev = skb; 884 if (skb_prev) 885 fraggap = skb_prev->len - maxfraglen; 886 else 887 fraggap = 0; 888 889 /* 890 * If remaining data exceeds the mtu, 891 * we know we need more fragment(s). 892 */ 893 datalen = length + fraggap; 894 if (datalen > mtu - fragheaderlen) 895 datalen = maxfraglen - fragheaderlen; 896 fraglen = datalen + fragheaderlen; 897 898 if ((flags & MSG_MORE) && 899 !(rt->u.dst.dev->features&NETIF_F_SG)) 900 alloclen = mtu; 901 else 902 alloclen = datalen + fragheaderlen; 903 904 /* The last fragment gets additional space at tail. 905 * Note, with MSG_MORE we overallocate on fragments, 906 * because we have no idea what fragment will be 907 * the last. 908 */ 909 if (datalen == length + fraggap) 910 alloclen += rt->u.dst.trailer_len; 911 912 if (transhdrlen) { 913 skb = sock_alloc_send_skb(sk, 914 alloclen + hh_len + 15, 915 (flags & MSG_DONTWAIT), &err); 916 } else { 917 skb = NULL; 918 if (atomic_read(&sk->sk_wmem_alloc) <= 919 2 * sk->sk_sndbuf) 920 skb = sock_wmalloc(sk, 921 alloclen + hh_len + 15, 1, 922 sk->sk_allocation); 923 if (unlikely(skb == NULL)) 924 err = -ENOBUFS; 925 } 926 if (skb == NULL) 927 goto error; 928 929 /* 930 * Fill in the control structures 931 */ 932 skb->ip_summed = csummode; 933 skb->csum = 0; 934 skb_reserve(skb, hh_len); 935 936 /* 937 * Find where to start putting bytes. 938 */ 939 data = skb_put(skb, fraglen); 940 skb_set_network_header(skb, exthdrlen); 941 skb->transport_header = (skb->network_header + 942 fragheaderlen); 943 data += fragheaderlen; 944 945 if (fraggap) { 946 skb->csum = skb_copy_and_csum_bits( 947 skb_prev, maxfraglen, 948 data + transhdrlen, fraggap, 0); 949 skb_prev->csum = csum_sub(skb_prev->csum, 950 skb->csum); 951 data += fraggap; 952 pskb_trim_unique(skb_prev, maxfraglen); 953 } 954 955 copy = datalen - transhdrlen - fraggap; 956 if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) { 957 err = -EFAULT; 958 kfree_skb(skb); 959 goto error; 960 } 961 962 offset += copy; 963 length -= datalen - fraggap; 964 transhdrlen = 0; 965 exthdrlen = 0; 966 csummode = CHECKSUM_NONE; 967 968 /* 969 * Put the packet on the pending queue. 970 */ 971 __skb_queue_tail(&sk->sk_write_queue, skb); 972 continue; 973 } 974 975 if (copy > length) 976 copy = length; 977 978 if (!(rt->u.dst.dev->features&NETIF_F_SG)) { 979 unsigned int off; 980 981 off = skb->len; 982 if (getfrag(from, skb_put(skb, copy), 983 offset, copy, off, skb) < 0) { 984 __skb_trim(skb, off); 985 err = -EFAULT; 986 goto error; 987 } 988 } else { 989 int i = skb_shinfo(skb)->nr_frags; 990 skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1]; 991 struct page *page = sk->sk_sndmsg_page; 992 int off = sk->sk_sndmsg_off; 993 unsigned int left; 994 995 if (page && (left = PAGE_SIZE - off) > 0) { 996 if (copy >= left) 997 copy = left; 998 if (page != frag->page) { 999 if (i == MAX_SKB_FRAGS) { 1000 err = -EMSGSIZE; 1001 goto error; 1002 } 1003 get_page(page); 1004 skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0); 1005 frag = &skb_shinfo(skb)->frags[i]; 1006 } 1007 } else if (i < MAX_SKB_FRAGS) { 1008 if (copy > PAGE_SIZE) 1009 copy = PAGE_SIZE; 1010 page = alloc_pages(sk->sk_allocation, 0); 1011 if (page == NULL) { 1012 err = -ENOMEM; 1013 goto error; 1014 } 1015 sk->sk_sndmsg_page = page; 1016 sk->sk_sndmsg_off = 0; 1017 1018 skb_fill_page_desc(skb, i, page, 0, 0); 1019 frag = &skb_shinfo(skb)->frags[i]; 1020 skb->truesize += PAGE_SIZE; 1021 atomic_add(PAGE_SIZE, &sk->sk_wmem_alloc); 1022 } else { 1023 err = -EMSGSIZE; 1024 goto error; 1025 } 1026 if (getfrag(from, page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) { 1027 err = -EFAULT; 1028 goto error; 1029 } 1030 sk->sk_sndmsg_off += copy; 1031 frag->size += copy; 1032 skb->len += copy; 1033 skb->data_len += copy; 1034 } 1035 offset += copy; 1036 length -= copy; 1037 } 1038 1039 return 0; 1040 1041 error: 1042 inet->cork.length -= length; 1043 IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 1044 return err; 1045 } 1046 1047 ssize_t ip_append_page(struct sock *sk, struct page *page, 1048 int offset, size_t size, int flags) 1049 { 1050 struct inet_sock *inet = inet_sk(sk); 1051 struct sk_buff *skb; 1052 struct rtable *rt; 1053 struct ip_options *opt = NULL; 1054 int hh_len; 1055 int mtu; 1056 int len; 1057 int err; 1058 unsigned int maxfraglen, fragheaderlen, fraggap; 1059 1060 if (inet->hdrincl) 1061 return -EPERM; 1062 1063 if (flags&MSG_PROBE) 1064 return 0; 1065 1066 if (skb_queue_empty(&sk->sk_write_queue)) 1067 return -EINVAL; 1068 1069 rt = inet->cork.rt; 1070 if (inet->cork.flags & IPCORK_OPT) 1071 opt = inet->cork.opt; 1072 1073 if (!(rt->u.dst.dev->features&NETIF_F_SG)) 1074 return -EOPNOTSUPP; 1075 1076 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev); 1077 mtu = inet->cork.fragsize; 1078 1079 fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0); 1080 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen; 1081 1082 if (inet->cork.length + size > 0xFFFF - fragheaderlen) { 1083 ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu); 1084 return -EMSGSIZE; 1085 } 1086 1087 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) 1088 return -EINVAL; 1089 1090 inet->cork.length += size; 1091 if ((sk->sk_protocol == IPPROTO_UDP) && 1092 (rt->u.dst.dev->features & NETIF_F_UFO)) { 1093 skb_shinfo(skb)->gso_size = mtu - fragheaderlen; 1094 skb_shinfo(skb)->gso_type = SKB_GSO_UDP; 1095 } 1096 1097 1098 while (size > 0) { 1099 int i; 1100 1101 if (skb_is_gso(skb)) 1102 len = size; 1103 else { 1104 1105 /* Check if the remaining data fits into current packet. */ 1106 len = mtu - skb->len; 1107 if (len < size) 1108 len = maxfraglen - skb->len; 1109 } 1110 if (len <= 0) { 1111 struct sk_buff *skb_prev; 1112 int alloclen; 1113 1114 skb_prev = skb; 1115 fraggap = skb_prev->len - maxfraglen; 1116 1117 alloclen = fragheaderlen + hh_len + fraggap + 15; 1118 skb = sock_wmalloc(sk, alloclen, 1, sk->sk_allocation); 1119 if (unlikely(!skb)) { 1120 err = -ENOBUFS; 1121 goto error; 1122 } 1123 1124 /* 1125 * Fill in the control structures 1126 */ 1127 skb->ip_summed = CHECKSUM_NONE; 1128 skb->csum = 0; 1129 skb_reserve(skb, hh_len); 1130 1131 /* 1132 * Find where to start putting bytes. 1133 */ 1134 skb_put(skb, fragheaderlen + fraggap); 1135 skb_reset_network_header(skb); 1136 skb->transport_header = (skb->network_header + 1137 fragheaderlen); 1138 if (fraggap) { 1139 skb->csum = skb_copy_and_csum_bits(skb_prev, 1140 maxfraglen, 1141 skb_transport_header(skb), 1142 fraggap, 0); 1143 skb_prev->csum = csum_sub(skb_prev->csum, 1144 skb->csum); 1145 pskb_trim_unique(skb_prev, maxfraglen); 1146 } 1147 1148 /* 1149 * Put the packet on the pending queue. 1150 */ 1151 __skb_queue_tail(&sk->sk_write_queue, skb); 1152 continue; 1153 } 1154 1155 i = skb_shinfo(skb)->nr_frags; 1156 if (len > size) 1157 len = size; 1158 if (skb_can_coalesce(skb, i, page, offset)) { 1159 skb_shinfo(skb)->frags[i-1].size += len; 1160 } else if (i < MAX_SKB_FRAGS) { 1161 get_page(page); 1162 skb_fill_page_desc(skb, i, page, offset, len); 1163 } else { 1164 err = -EMSGSIZE; 1165 goto error; 1166 } 1167 1168 if (skb->ip_summed == CHECKSUM_NONE) { 1169 __wsum csum; 1170 csum = csum_page(page, offset, len); 1171 skb->csum = csum_block_add(skb->csum, csum, skb->len); 1172 } 1173 1174 skb->len += len; 1175 skb->data_len += len; 1176 offset += len; 1177 size -= len; 1178 } 1179 return 0; 1180 1181 error: 1182 inet->cork.length -= size; 1183 IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 1184 return err; 1185 } 1186 1187 /* 1188 * Combined all pending IP fragments on the socket as one IP datagram 1189 * and push them out. 1190 */ 1191 int ip_push_pending_frames(struct sock *sk) 1192 { 1193 struct sk_buff *skb, *tmp_skb; 1194 struct sk_buff **tail_skb; 1195 struct inet_sock *inet = inet_sk(sk); 1196 struct ip_options *opt = NULL; 1197 struct rtable *rt = inet->cork.rt; 1198 struct iphdr *iph; 1199 __be16 df = 0; 1200 __u8 ttl; 1201 int err = 0; 1202 1203 if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL) 1204 goto out; 1205 tail_skb = &(skb_shinfo(skb)->frag_list); 1206 1207 /* move skb->data to ip header from ext header */ 1208 if (skb->data < skb_network_header(skb)) 1209 __skb_pull(skb, skb_network_offset(skb)); 1210 while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) { 1211 __skb_pull(tmp_skb, skb_network_header_len(skb)); 1212 *tail_skb = tmp_skb; 1213 tail_skb = &(tmp_skb->next); 1214 skb->len += tmp_skb->len; 1215 skb->data_len += tmp_skb->len; 1216 skb->truesize += tmp_skb->truesize; 1217 __sock_put(tmp_skb->sk); 1218 tmp_skb->destructor = NULL; 1219 tmp_skb->sk = NULL; 1220 } 1221 1222 /* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow 1223 * to fragment the frame generated here. No matter, what transforms 1224 * how transforms change size of the packet, it will come out. 1225 */ 1226 if (inet->pmtudisc < IP_PMTUDISC_DO) 1227 skb->local_df = 1; 1228 1229 /* DF bit is set when we want to see DF on outgoing frames. 1230 * If local_df is set too, we still allow to fragment this frame 1231 * locally. */ 1232 if (inet->pmtudisc >= IP_PMTUDISC_DO || 1233 (skb->len <= dst_mtu(&rt->u.dst) && 1234 ip_dont_fragment(sk, &rt->u.dst))) 1235 df = htons(IP_DF); 1236 1237 if (inet->cork.flags & IPCORK_OPT) 1238 opt = inet->cork.opt; 1239 1240 if (rt->rt_type == RTN_MULTICAST) 1241 ttl = inet->mc_ttl; 1242 else 1243 ttl = ip_select_ttl(inet, &rt->u.dst); 1244 1245 iph = (struct iphdr *)skb->data; 1246 iph->version = 4; 1247 iph->ihl = 5; 1248 if (opt) { 1249 iph->ihl += opt->optlen>>2; 1250 ip_options_build(skb, opt, inet->cork.addr, rt, 0); 1251 } 1252 iph->tos = inet->tos; 1253 iph->tot_len = htons(skb->len); 1254 iph->frag_off = df; 1255 ip_select_ident(iph, &rt->u.dst, sk); 1256 iph->ttl = ttl; 1257 iph->protocol = sk->sk_protocol; 1258 iph->saddr = rt->rt_src; 1259 iph->daddr = rt->rt_dst; 1260 ip_send_check(iph); 1261 1262 skb->priority = sk->sk_priority; 1263 skb->dst = dst_clone(&rt->u.dst); 1264 1265 /* Netfilter gets whole the not fragmented skb. */ 1266 err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, 1267 skb->dst->dev, dst_output); 1268 if (err) { 1269 if (err > 0) 1270 err = inet->recverr ? net_xmit_errno(err) : 0; 1271 if (err) 1272 goto error; 1273 } 1274 1275 out: 1276 inet->cork.flags &= ~IPCORK_OPT; 1277 kfree(inet->cork.opt); 1278 inet->cork.opt = NULL; 1279 if (inet->cork.rt) { 1280 ip_rt_put(inet->cork.rt); 1281 inet->cork.rt = NULL; 1282 } 1283 return err; 1284 1285 error: 1286 IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 1287 goto out; 1288 } 1289 1290 /* 1291 * Throw away all pending data on the socket. 1292 */ 1293 void ip_flush_pending_frames(struct sock *sk) 1294 { 1295 struct inet_sock *inet = inet_sk(sk); 1296 struct sk_buff *skb; 1297 1298 while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) 1299 kfree_skb(skb); 1300 1301 inet->cork.flags &= ~IPCORK_OPT; 1302 kfree(inet->cork.opt); 1303 inet->cork.opt = NULL; 1304 if (inet->cork.rt) { 1305 ip_rt_put(inet->cork.rt); 1306 inet->cork.rt = NULL; 1307 } 1308 } 1309 1310 1311 /* 1312 * Fetch data from kernel space and fill in checksum if needed. 1313 */ 1314 static int ip_reply_glue_bits(void *dptr, char *to, int offset, 1315 int len, int odd, struct sk_buff *skb) 1316 { 1317 __wsum csum; 1318 1319 csum = csum_partial_copy_nocheck(dptr+offset, to, len, 0); 1320 skb->csum = csum_block_add(skb->csum, csum, odd); 1321 return 0; 1322 } 1323 1324 /* 1325 * Generic function to send a packet as reply to another packet. 1326 * Used to send TCP resets so far. ICMP should use this function too. 1327 * 1328 * Should run single threaded per socket because it uses the sock 1329 * structure to pass arguments. 1330 * 1331 * LATER: switch from ip_build_xmit to ip_append_* 1332 */ 1333 void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg, 1334 unsigned int len) 1335 { 1336 struct inet_sock *inet = inet_sk(sk); 1337 struct { 1338 struct ip_options opt; 1339 char data[40]; 1340 } replyopts; 1341 struct ipcm_cookie ipc; 1342 __be32 daddr; 1343 struct rtable *rt = (struct rtable*)skb->dst; 1344 1345 if (ip_options_echo(&replyopts.opt, skb)) 1346 return; 1347 1348 daddr = ipc.addr = rt->rt_src; 1349 ipc.opt = NULL; 1350 1351 if (replyopts.opt.optlen) { 1352 ipc.opt = &replyopts.opt; 1353 1354 if (ipc.opt->srr) 1355 daddr = replyopts.opt.faddr; 1356 } 1357 1358 { 1359 struct flowi fl = { .oif = arg->bound_dev_if, 1360 .nl_u = { .ip4_u = 1361 { .daddr = daddr, 1362 .saddr = rt->rt_spec_dst, 1363 .tos = RT_TOS(ip_hdr(skb)->tos) } }, 1364 /* Not quite clean, but right. */ 1365 .uli_u = { .ports = 1366 { .sport = tcp_hdr(skb)->dest, 1367 .dport = tcp_hdr(skb)->source } }, 1368 .proto = sk->sk_protocol }; 1369 security_skb_classify_flow(skb, &fl); 1370 if (ip_route_output_key(&rt, &fl)) 1371 return; 1372 } 1373 1374 /* And let IP do all the hard work. 1375 1376 This chunk is not reenterable, hence spinlock. 1377 Note that it uses the fact, that this function is called 1378 with locally disabled BH and that sk cannot be already spinlocked. 1379 */ 1380 bh_lock_sock(sk); 1381 inet->tos = ip_hdr(skb)->tos; 1382 sk->sk_priority = skb->priority; 1383 sk->sk_protocol = ip_hdr(skb)->protocol; 1384 sk->sk_bound_dev_if = arg->bound_dev_if; 1385 ip_append_data(sk, ip_reply_glue_bits, arg->iov->iov_base, len, 0, 1386 &ipc, rt, MSG_DONTWAIT); 1387 if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) { 1388 if (arg->csumoffset >= 0) 1389 *((__sum16 *)skb_transport_header(skb) + 1390 arg->csumoffset) = csum_fold(csum_add(skb->csum, 1391 arg->csum)); 1392 skb->ip_summed = CHECKSUM_NONE; 1393 ip_push_pending_frames(sk); 1394 } 1395 1396 bh_unlock_sock(sk); 1397 1398 ip_rt_put(rt); 1399 } 1400 1401 void __init ip_init(void) 1402 { 1403 ip_rt_init(); 1404 inet_initpeers(); 1405 1406 #if defined(CONFIG_IP_MULTICAST) && defined(CONFIG_PROC_FS) 1407 igmp_mc_proc_init(); 1408 #endif 1409 } 1410 1411 EXPORT_SYMBOL(ip_generic_getfrag); 1412 EXPORT_SYMBOL(ip_queue_xmit); 1413 EXPORT_SYMBOL(ip_send_check); 1414