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