git.oblomov.eu Git - linux-2.6/blob - net/ipv4/ip_output.c

   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 = { .nl_u = { .ip4_u =
1356                                               { .daddr = daddr,
1357                                                 .saddr = rt->rt_spec_dst,
1358                                                 .tos = RT_TOS(ip_hdr(skb)->tos) } },
1359                                     /* Not quite clean, but right. */
1360                                     .uli_u = { .ports =
1361                                                { .sport = tcp_hdr(skb)->dest,
1362                                                  .dport = tcp_hdr(skb)->source } },
1363                                     .proto = sk->sk_protocol };
1364                 security_skb_classify_flow(skb, &fl);
1365                 if (ip_route_output_key(&rt, &fl))
1366                         return;
1367         }
1368
1369         /* And let IP do all the hard work.
1370
1371            This chunk is not reenterable, hence spinlock.
1372            Note that it uses the fact, that this function is called
1373            with locally disabled BH and that sk cannot be already spinlocked.
1374          */
1375         bh_lock_sock(sk);
1376         inet->tos = ip_hdr(skb)->tos;
1377         sk->sk_priority = skb->priority;
1378         sk->sk_protocol = ip_hdr(skb)->protocol;
1379         ip_append_data(sk, ip_reply_glue_bits, arg->iov->iov_base, len, 0,
1380                        &ipc, rt, MSG_DONTWAIT);
1381         if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
1382                 if (arg->csumoffset >= 0)
1383                         *((__sum16 *)skb_transport_header(skb) +
1384                           arg->csumoffset) = csum_fold(csum_add(skb->csum,
1385                                                                 arg->csum));
1386                 skb->ip_summed = CHECKSUM_NONE;
1387                 ip_push_pending_frames(sk);
1388         }
1389
1390         bh_unlock_sock(sk);
1391
1392         ip_rt_put(rt);
1393 }
1394
1395 void __init ip_init(void)
1396 {
1397         ip_rt_init();
1398         inet_initpeers();
1399
1400 #if defined(CONFIG_IP_MULTICAST) && defined(CONFIG_PROC_FS)
1401         igmp_mc_proc_init();
1402 #endif
1403 }
1404
1405 EXPORT_SYMBOL(ip_generic_getfrag);
1406 EXPORT_SYMBOL(ip_queue_xmit);
1407 EXPORT_SYMBOL(ip_send_check);