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