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