v2.4.8 -> v2.4.8.1
[opensuse:kernel.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.97 2001/08/09 17:53:40 davem Exp $
9  *
10  * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
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  *
19  *      See ip_input.c for original log
20  *
21  *      Fixes:
22  *              Alan Cox        :       Missing nonblock feature in ip_build_xmit.
23  *              Mike Kilburn    :       htons() missing in ip_build_xmit.
24  *              Bradford Johnson:       Fix faulty handling of some frames when 
25  *                                      no route is found.
26  *              Alexander Demenshin:    Missing sk/skb free in ip_queue_xmit
27  *                                      (in case if packet not accepted by
28  *                                      output firewall rules)
29  *              Mike McLagan    :       Routing by source
30  *              Alexey Kuznetsov:       use new route cache
31  *              Andi Kleen:             Fix broken PMTU recovery and remove
32  *                                      some redundant tests.
33  *      Vitaly E. Lavrov        :       Transparent proxy revived after year coma.
34  *              Andi Kleen      :       Replace ip_reply with ip_send_reply.
35  *              Andi Kleen      :       Split fast and slow ip_build_xmit path 
36  *                                      for decreased register pressure on x86 
37  *                                      and more readibility. 
38  *              Marc Boucher    :       When call_out_firewall returns FW_QUEUE,
39  *                                      silently drop skb instead of failing with -EPERM.
40  *              Detlev Wengorz  :       Copy protocol for fragments.
41  */
42
43 #include <asm/uaccess.h>
44 #include <asm/system.h>
45 #include <linux/types.h>
46 #include <linux/kernel.h>
47 #include <linux/sched.h>
48 #include <linux/mm.h>
49 #include <linux/string.h>
50 #include <linux/errno.h>
51 #include <linux/config.h>
52
53 #include <linux/socket.h>
54 #include <linux/sockios.h>
55 #include <linux/in.h>
56 #include <linux/inet.h>
57 #include <linux/netdevice.h>
58 #include <linux/etherdevice.h>
59 #include <linux/proc_fs.h>
60 #include <linux/stat.h>
61 #include <linux/init.h>
62
63 #include <net/snmp.h>
64 #include <net/ip.h>
65 #include <net/protocol.h>
66 #include <net/route.h>
67 #include <net/tcp.h>
68 #include <net/udp.h>
69 #include <linux/skbuff.h>
70 #include <net/sock.h>
71 #include <net/arp.h>
72 #include <net/icmp.h>
73 #include <net/raw.h>
74 #include <net/checksum.h>
75 #include <net/inetpeer.h>
76 #include <linux/igmp.h>
77 #include <linux/netfilter_ipv4.h>
78 #include <linux/mroute.h>
79 #include <linux/netlink.h>
80
81 /*
82  *      Shall we try to damage output packets if routing dev changes?
83  */
84
85 int sysctl_ip_dynaddr = 0;
86 int sysctl_ip_default_ttl = 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         newskb->mac.raw = newskb->data;
99         __skb_pull(newskb, newskb->nh.raw - newskb->data);
100         newskb->pkt_type = PACKET_LOOPBACK;
101         newskb->ip_summed = CHECKSUM_UNNECESSARY;
102         BUG_TRAP(newskb->dst);
103
104 #ifdef CONFIG_NETFILTER_DEBUG
105         nf_debug_ip_loopback_xmit(newskb);
106 #endif
107         netif_rx(newskb);
108         return 0;
109 }
110
111 /* Don't just hand NF_HOOK skb->dst->output, in case netfilter hook
112    changes route */
113 static inline int
114 output_maybe_reroute(struct sk_buff *skb)
115 {
116         return skb->dst->output(skb);
117 }
118
119 /* 
120  *              Add an ip header to a skbuff and send it out.
121  */
122 int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
123                           u32 saddr, u32 daddr, struct ip_options *opt)
124 {
125         struct rtable *rt = (struct rtable *)skb->dst;
126         struct iphdr *iph;
127
128         /* Build the IP header. */
129         if (opt)
130                 iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr) + opt->optlen);
131         else
132                 iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr));
133
134         iph->version  = 4;
135         iph->ihl      = 5;
136         iph->tos      = sk->protinfo.af_inet.tos;
137         iph->frag_off = 0;
138         if (ip_dont_fragment(sk, &rt->u.dst))
139                 iph->frag_off |= htons(IP_DF);
140         iph->ttl      = sk->protinfo.af_inet.ttl;
141         iph->daddr    = rt->rt_dst;
142         iph->saddr    = rt->rt_src;
143         iph->protocol = sk->protocol;
144         iph->tot_len  = htons(skb->len);
145         ip_select_ident(iph, &rt->u.dst, sk);
146         skb->nh.iph   = iph;
147
148         if (opt && opt->optlen) {
149                 iph->ihl += opt->optlen>>2;
150                 ip_options_build(skb, opt, daddr, rt, 0);
151         }
152         ip_send_check(iph);
153
154         /* Send it out. */
155         return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
156                        output_maybe_reroute);
157 }
158
159 static inline int ip_finish_output2(struct sk_buff *skb)
160 {
161         struct dst_entry *dst = skb->dst;
162         struct hh_cache *hh = dst->hh;
163
164 #ifdef CONFIG_NETFILTER_DEBUG
165         nf_debug_ip_finish_output2(skb);
166 #endif /*CONFIG_NETFILTER_DEBUG*/
167
168         if (hh) {
169                 read_lock_bh(&hh->hh_lock);
170                 memcpy(skb->data - 16, hh->hh_data, 16);
171                 read_unlock_bh(&hh->hh_lock);
172                 skb_push(skb, hh->hh_len);
173                 return hh->hh_output(skb);
174         } else if (dst->neighbour)
175                 return dst->neighbour->output(skb);
176
177         printk(KERN_DEBUG "khm\n");
178         kfree_skb(skb);
179         return -EINVAL;
180 }
181
182 __inline__ int ip_finish_output(struct sk_buff *skb)
183 {
184         struct net_device *dev = skb->dst->dev;
185
186         skb->dev = dev;
187         skb->protocol = __constant_htons(ETH_P_IP);
188
189         return NF_HOOK(PF_INET, NF_IP_POST_ROUTING, skb, NULL, dev,
190                        ip_finish_output2);
191 }
192
193 int ip_mc_output(struct sk_buff *skb)
194 {
195         struct sock *sk = skb->sk;
196         struct rtable *rt = (struct rtable*)skb->dst;
197         struct net_device *dev = rt->u.dst.dev;
198
199         /*
200          *      If the indicated interface is up and running, send the packet.
201          */
202         IP_INC_STATS(IpOutRequests);
203 #ifdef CONFIG_IP_ROUTE_NAT
204         if (rt->rt_flags & RTCF_NAT)
205                 ip_do_nat(skb);
206 #endif
207
208         skb->dev = dev;
209         skb->protocol = __constant_htons(ETH_P_IP);
210
211         /*
212          *      Multicasts are looped back for other local users
213          */
214
215         if (rt->rt_flags&RTCF_MULTICAST) {
216                 if ((!sk || sk->protinfo.af_inet.mc_loop)
217 #ifdef CONFIG_IP_MROUTE
218                 /* Small optimization: do not loopback not local frames,
219                    which returned after forwarding; they will be  dropped
220                    by ip_mr_input in any case.
221                    Note, that local frames are looped back to be delivered
222                    to local recipients.
223
224                    This check is duplicated in ip_mr_input at the moment.
225                  */
226                     && ((rt->rt_flags&RTCF_LOCAL) || !(IPCB(skb)->flags&IPSKB_FORWARDED))
227 #endif
228                 ) {
229                         struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
230                         if (newskb)
231                                 NF_HOOK(PF_INET, NF_IP_POST_ROUTING, newskb, NULL,
232                                         newskb->dev, 
233                                         ip_dev_loopback_xmit);
234                 }
235
236                 /* Multicasts with ttl 0 must not go beyond the host */
237
238                 if (skb->nh.iph->ttl == 0) {
239                         kfree_skb(skb);
240                         return 0;
241                 }
242         }
243
244         if (rt->rt_flags&RTCF_BROADCAST) {
245                 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
246                 if (newskb)
247                         NF_HOOK(PF_INET, NF_IP_POST_ROUTING, newskb, NULL,
248                                 newskb->dev, ip_dev_loopback_xmit);
249         }
250
251         return ip_finish_output(skb);
252 }
253
254 int ip_output(struct sk_buff *skb)
255 {
256 #ifdef CONFIG_IP_ROUTE_NAT
257         struct rtable *rt = (struct rtable*)skb->dst;
258 #endif
259
260         IP_INC_STATS(IpOutRequests);
261
262 #ifdef CONFIG_IP_ROUTE_NAT
263         if (rt->rt_flags&RTCF_NAT)
264                 ip_do_nat(skb);
265 #endif
266
267         return ip_finish_output(skb);
268 }
269
270 /* Queues a packet to be sent, and starts the transmitter if necessary.  
271  * This routine also needs to put in the total length and compute the 
272  * checksum.  We use to do this in two stages, ip_build_header() then
273  * this, but that scheme created a mess when routes disappeared etc.
274  * So we do it all here, and the TCP send engine has been changed to
275  * match. (No more unroutable FIN disasters, etc. wheee...)  This will
276  * most likely make other reliable transport layers above IP easier
277  * to implement under Linux.
278  */
279 static inline int ip_queue_xmit2(struct sk_buff *skb)
280 {
281         struct sock *sk = skb->sk;
282         struct rtable *rt = (struct rtable *)skb->dst;
283         struct net_device *dev;
284         struct iphdr *iph = skb->nh.iph;
285
286         dev = rt->u.dst.dev;
287
288         /* This can happen when the transport layer has segments queued
289          * with a cached route, and by the time we get here things are
290          * re-routed to a device with a different MTU than the original
291          * device.  Sick, but we must cover it.
292          */
293         if (skb_headroom(skb) < dev->hard_header_len && dev->hard_header) {
294                 struct sk_buff *skb2;
295
296                 skb2 = skb_realloc_headroom(skb, (dev->hard_header_len + 15) & ~15);
297                 kfree_skb(skb);
298                 if (skb2 == NULL)
299                         return -ENOMEM;
300                 if (sk)
301                         skb_set_owner_w(skb2, sk);
302                 skb = skb2;
303                 iph = skb->nh.iph;
304         }
305
306         if (skb->len > rt->u.dst.pmtu)
307                 goto fragment;
308
309         if (ip_dont_fragment(sk, &rt->u.dst))
310                 iph->frag_off |= __constant_htons(IP_DF);
311
312         ip_select_ident(iph, &rt->u.dst, sk);
313
314         /* Add an IP checksum. */
315         ip_send_check(iph);
316
317         skb->priority = sk->priority;
318         return skb->dst->output(skb);
319
320 fragment:
321         if (ip_dont_fragment(sk, &rt->u.dst)) {
322                 /* Reject packet ONLY if TCP might fragment
323                  * it itself, if were careful enough.
324                  */
325                 iph->frag_off |= __constant_htons(IP_DF);
326                 NETDEBUG(printk(KERN_DEBUG "sending pkt_too_big to self\n"));
327
328                 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
329                           htonl(rt->u.dst.pmtu));
330                 kfree_skb(skb);
331                 return -EMSGSIZE;
332         }
333         ip_select_ident(iph, &rt->u.dst, sk);
334         if (skb->ip_summed == CHECKSUM_HW &&
335             (skb = skb_checksum_help(skb)) == NULL)
336                 return -ENOMEM;
337         return ip_fragment(skb, skb->dst->output);
338 }
339
340 int ip_queue_xmit(struct sk_buff *skb)
341 {
342         struct sock *sk = skb->sk;
343         struct ip_options *opt = sk->protinfo.af_inet.opt;
344         struct rtable *rt;
345         struct iphdr *iph;
346
347         /* Skip all of this if the packet is already routed,
348          * f.e. by something like SCTP.
349          */
350         rt = (struct rtable *) skb->dst;
351         if (rt != NULL)
352                 goto packet_routed;
353
354         /* Make sure we can route this packet. */
355         rt = (struct rtable *)__sk_dst_check(sk, 0);
356         if (rt == NULL) {
357                 u32 daddr;
358
359                 /* Use correct destination address if we have options. */
360                 daddr = sk->daddr;
361                 if(opt && opt->srr)
362                         daddr = opt->faddr;
363
364                 /* If this fails, retransmit mechanism of transport layer will
365                  * keep trying until route appears or the connection times itself
366                  * out.
367                  */
368                 if (ip_route_output(&rt, daddr, sk->saddr,
369                                     RT_TOS(sk->protinfo.af_inet.tos) | RTO_CONN | sk->localroute,
370                                     sk->bound_dev_if))
371                         goto no_route;
372                 __sk_dst_set(sk, &rt->u.dst);
373                 sk->route_caps = rt->u.dst.dev->features;
374         }
375         skb->dst = dst_clone(&rt->u.dst);
376
377 packet_routed:
378         if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)
379                 goto no_route;
380
381         /* OK, we know where to send it, allocate and build IP header. */
382         iph = (struct iphdr *) skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0));
383         *((__u16 *)iph) = htons((4 << 12) | (5 << 8) | (sk->protinfo.af_inet.tos & 0xff));
384         iph->tot_len = htons(skb->len);
385         iph->frag_off = 0;
386         iph->ttl      = sk->protinfo.af_inet.ttl;
387         iph->protocol = sk->protocol;
388         iph->saddr    = rt->rt_src;
389         iph->daddr    = rt->rt_dst;
390         skb->nh.iph   = iph;
391         /* Transport layer set skb->h.foo itself. */
392
393         if(opt && opt->optlen) {
394                 iph->ihl += opt->optlen >> 2;
395                 ip_options_build(skb, opt, sk->daddr, rt, 0);
396         }
397
398         return NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
399                        ip_queue_xmit2);
400
401 no_route:
402         IP_INC_STATS(IpOutNoRoutes);
403         kfree_skb(skb);
404         return -EHOSTUNREACH;
405 }
406
407 /*
408  *      Build and send a packet, with as little as one copy
409  *
410  *      Doesn't care much about ip options... option length can be
411  *      different for fragment at 0 and other fragments.
412  *
413  *      Note that the fragment at the highest offset is sent first,
414  *      so the getfrag routine can fill in the TCP/UDP checksum header
415  *      field in the last fragment it sends... actually it also helps
416  *      the reassemblers, they can put most packets in at the head of
417  *      the fragment queue, and they know the total size in advance. This
418  *      last feature will measurably improve the Linux fragment handler one
419  *      day.
420  *
421  *      The callback has five args, an arbitrary pointer (copy of frag),
422  *      the source IP address (may depend on the routing table), the 
423  *      destination address (char *), the offset to copy from, and the
424  *      length to be copied.
425  */
426
427 static int ip_build_xmit_slow(struct sock *sk,
428                   int getfrag (const void *,
429                                char *,
430                                unsigned int,    
431                                unsigned int),
432                   const void *frag,
433                   unsigned length,
434                   struct ipcm_cookie *ipc,
435                   struct rtable *rt,
436                   int flags)
437 {
438         unsigned int fraglen, maxfraglen, fragheaderlen;
439         int err;
440         int offset, mf;
441         int mtu;
442         u16 id;
443
444         int hh_len = (rt->u.dst.dev->hard_header_len + 15)&~15;
445         int nfrags=0;
446         struct ip_options *opt = ipc->opt;
447         int df = 0;
448
449         mtu = rt->u.dst.pmtu;
450         if (ip_dont_fragment(sk, &rt->u.dst))
451                 df = htons(IP_DF);
452
453         length -= sizeof(struct iphdr);
454
455         if (opt) {
456                 fragheaderlen = sizeof(struct iphdr) + opt->optlen;
457                 maxfraglen = ((mtu-sizeof(struct iphdr)-opt->optlen) & ~7) + fragheaderlen;
458         } else {
459                 fragheaderlen = sizeof(struct iphdr);
460
461                 /*
462                  *      Fragheaderlen is the size of 'overhead' on each buffer. Now work
463                  *      out the size of the frames to send.
464                  */
465
466                 maxfraglen = ((mtu-sizeof(struct iphdr)) & ~7) + fragheaderlen;
467         }
468
469         if (length + fragheaderlen > 0xFFFF) {
470                 ip_local_error(sk, EMSGSIZE, rt->rt_dst, sk->dport, mtu);
471                 return -EMSGSIZE;
472         }
473
474         /*
475          *      Start at the end of the frame by handling the remainder.
476          */
477
478         offset = length - (length % (maxfraglen - fragheaderlen));
479
480         /*
481          *      Amount of memory to allocate for final fragment.
482          */
483
484         fraglen = length - offset + fragheaderlen;
485
486         if (length-offset==0) {
487                 fraglen = maxfraglen;
488                 offset -= maxfraglen-fragheaderlen;
489         }
490
491         /*
492          *      The last fragment will not have MF (more fragments) set.
493          */
494
495         mf = 0;
496
497         /*
498          *      Don't fragment packets for path mtu discovery.
499          */
500
501         if (offset > 0 && sk->protinfo.af_inet.pmtudisc==IP_PMTUDISC_DO) { 
502                 ip_local_error(sk, EMSGSIZE, rt->rt_dst, sk->dport, mtu);
503                 return -EMSGSIZE;
504         }
505         if (flags&MSG_PROBE)
506                 goto out;
507
508         /*
509          *      Begin outputting the bytes.
510          */
511
512         id = sk->protinfo.af_inet.id++;
513
514         do {
515                 char *data;
516                 struct sk_buff * skb;
517
518                 /*
519                  *      Get the memory we require with some space left for alignment.
520                  */
521
522                 skb = sock_alloc_send_skb(sk, fraglen+hh_len+15, flags&MSG_DONTWAIT, &err);
523                 if (skb == NULL)
524                         goto error;
525
526                 /*
527                  *      Fill in the control structures
528                  */
529
530                 skb->priority = sk->priority;
531                 skb->dst = dst_clone(&rt->u.dst);
532                 skb_reserve(skb, hh_len);
533
534                 /*
535                  *      Find where to start putting bytes.
536                  */
537
538                 data = skb_put(skb, fraglen);
539                 skb->nh.iph = (struct iphdr *)data;
540
541                 /*
542                  *      Only write IP header onto non-raw packets 
543                  */
544
545                 {
546                         struct iphdr *iph = (struct iphdr *)data;
547
548                         iph->version = 4;
549                         iph->ihl = 5;
550                         if (opt) {
551                                 iph->ihl += opt->optlen>>2;
552                                 ip_options_build(skb, opt,
553                                                  ipc->addr, rt, offset);
554                         }
555                         iph->tos = sk->protinfo.af_inet.tos;
556                         iph->tot_len = htons(fraglen - fragheaderlen + iph->ihl*4);
557                         iph->frag_off = htons(offset>>3)|mf|df;
558                         iph->id = id;
559                         if (!mf) {
560                                 if (offset || !df) {
561                                         /* Select an unpredictable ident only
562                                          * for packets without DF or having
563                                          * been fragmented.
564                                          */
565                                         __ip_select_ident(iph, &rt->u.dst);
566                                         id = iph->id;
567                                 }
568
569                                 /*
570                                  *      Any further fragments will have MF set.
571                                  */
572                                 mf = htons(IP_MF);
573                         }
574                         if (rt->rt_type == RTN_MULTICAST)
575                                 iph->ttl = sk->protinfo.af_inet.mc_ttl;
576                         else
577                                 iph->ttl = sk->protinfo.af_inet.ttl;
578                         iph->protocol = sk->protocol;
579                         iph->check = 0;
580                         iph->saddr = rt->rt_src;
581                         iph->daddr = rt->rt_dst;
582                         iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
583                         data += iph->ihl*4;
584                 }
585
586                 /*
587                  *      User data callback
588                  */
589
590                 if (getfrag(frag, data, offset, fraglen-fragheaderlen)) {
591                         err = -EFAULT;
592                         kfree_skb(skb);
593                         goto error;
594                 }
595
596                 offset -= (maxfraglen-fragheaderlen);
597                 fraglen = maxfraglen;
598
599                 nfrags++;
600
601                 err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, 
602                               skb->dst->dev, output_maybe_reroute);
603                 if (err) {
604                         if (err > 0)
605                                 err = sk->protinfo.af_inet.recverr ? net_xmit_errno(err) : 0;
606                         if (err)
607                                 goto error;
608                 }
609         } while (offset >= 0);
610
611         if (nfrags>1)
612                 ip_statistics[smp_processor_id()*2 + !in_softirq()].IpFragCreates += nfrags;
613 out:
614         return 0;
615
616 error:
617         IP_INC_STATS(IpOutDiscards);
618         if (nfrags>1)
619                 ip_statistics[smp_processor_id()*2 + !in_softirq()].IpFragCreates += nfrags;
620         return err; 
621 }
622
623 /*
624  *      Fast path for unfragmented packets.
625  */
626 int ip_build_xmit(struct sock *sk, 
627                   int getfrag (const void *,
628                                char *,
629                                unsigned int,    
630                                unsigned int),
631                   const void *frag,
632                   unsigned length,
633                   struct ipcm_cookie *ipc,
634                   struct rtable *rt,
635                   int flags)
636 {
637         int err;
638         struct sk_buff *skb;
639         int df;
640         struct iphdr *iph;
641
642         /*
643          *      Try the simple case first. This leaves fragmented frames, and by
644          *      choice RAW frames within 20 bytes of maximum size(rare) to the long path
645          */
646
647         if (!sk->protinfo.af_inet.hdrincl) {
648                 length += sizeof(struct iphdr);
649
650                 /*
651                  *      Check for slow path.
652                  */
653                 if (length > rt->u.dst.pmtu || ipc->opt != NULL)  
654                         return ip_build_xmit_slow(sk,getfrag,frag,length,ipc,rt,flags); 
655         } else {
656                 if (length > rt->u.dst.dev->mtu) {
657                         ip_local_error(sk, EMSGSIZE, rt->rt_dst, sk->dport, rt->u.dst.dev->mtu);
658                         return -EMSGSIZE;
659                 }
660         }
661         if (flags&MSG_PROBE)
662                 goto out;
663
664         /*
665          *      Do path mtu discovery if needed.
666          */
667         df = 0;
668         if (ip_dont_fragment(sk, &rt->u.dst))
669                 df = htons(IP_DF);
670
671         /* 
672          *      Fast path for unfragmented frames without options. 
673          */ 
674         {
675         int hh_len = (rt->u.dst.dev->hard_header_len + 15)&~15;
676
677         skb = sock_alloc_send_skb(sk, length+hh_len+15,
678                                   flags&MSG_DONTWAIT, &err);
679         if(skb==NULL)
680                 goto error; 
681         skb_reserve(skb, hh_len);
682         }
683
684         skb->priority = sk->priority;
685         skb->dst = dst_clone(&rt->u.dst);
686
687         skb->nh.iph = iph = (struct iphdr *)skb_put(skb, length);
688
689         if(!sk->protinfo.af_inet.hdrincl) {
690                 iph->version=4;
691                 iph->ihl=5;
692                 iph->tos=sk->protinfo.af_inet.tos;
693                 iph->tot_len = htons(length);
694                 iph->frag_off = df;
695                 iph->ttl=sk->protinfo.af_inet.mc_ttl;
696                 ip_select_ident(iph, &rt->u.dst, sk);
697                 if (rt->rt_type != RTN_MULTICAST)
698                         iph->ttl=sk->protinfo.af_inet.ttl;
699                 iph->protocol=sk->protocol;
700                 iph->saddr=rt->rt_src;
701                 iph->daddr=rt->rt_dst;
702                 iph->check=0;
703                 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
704                 err = getfrag(frag, ((char *)iph)+iph->ihl*4,0, length-iph->ihl*4);
705         }
706         else
707                 err = getfrag(frag, (void *)iph, 0, length);
708
709         if (err)
710                 goto error_fault;
711
712         err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
713                       output_maybe_reroute);
714         if (err > 0)
715                 err = sk->protinfo.af_inet.recverr ? net_xmit_errno(err) : 0;
716         if (err)
717                 goto error;
718 out:
719         return 0;
720
721 error_fault:
722         err = -EFAULT;
723         kfree_skb(skb);
724 error:
725         IP_INC_STATS(IpOutDiscards);
726         return err; 
727 }
728
729 /*
730  *      This IP datagram is too large to be sent in one piece.  Break it up into
731  *      smaller pieces (each of size equal to IP header plus
732  *      a block of the data of the original IP data part) that will yet fit in a
733  *      single device frame, and queue such a frame for sending.
734  *
735  *      Yes this is inefficient, feel free to submit a quicker one.
736  */
737
738 int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*))
739 {
740         struct iphdr *iph;
741         int raw = 0;
742         int ptr;
743         struct net_device *dev;
744         struct sk_buff *skb2;
745         unsigned int mtu, hlen, left, len; 
746         int offset;
747         int not_last_frag;
748         struct rtable *rt = (struct rtable*)skb->dst;
749         int err = 0;
750
751         dev = rt->u.dst.dev;
752
753         /*
754          *      Point into the IP datagram header.
755          */
756
757         iph = skb->nh.iph;
758
759         /*
760          *      Setup starting values.
761          */
762
763         hlen = iph->ihl * 4;
764         left = skb->len - hlen;         /* Space per frame */
765         mtu = rt->u.dst.pmtu - hlen;    /* Size of data space */
766         ptr = raw + hlen;               /* Where to start from */
767
768         /*
769          *      Fragment the datagram.
770          */
771
772         offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
773         not_last_frag = iph->frag_off & htons(IP_MF);
774
775         /*
776          *      Keep copying data until we run out.
777          */
778
779         while(left > 0) {
780                 len = left;
781                 /* IF: it doesn't fit, use 'mtu' - the data space left */
782                 if (len > mtu)
783                         len = mtu;
784                 /* IF: we are not sending upto and including the packet end
785                    then align the next start on an eight byte boundary */
786                 if (len < left) {
787                         len &= ~7;
788                 }
789                 /*
790                  *      Allocate buffer.
791                  */
792
793                 if ((skb2 = alloc_skb(len+hlen+dev->hard_header_len+15,GFP_ATOMIC)) == NULL) {
794                         NETDEBUG(printk(KERN_INFO "IP: frag: no memory for new fragment!\n"));
795                         err = -ENOMEM;
796                         goto fail;
797                 }
798
799                 /*
800                  *      Set up data on packet
801                  */
802
803                 skb2->pkt_type = skb->pkt_type;
804                 skb2->priority = skb->priority;
805                 skb_reserve(skb2, (dev->hard_header_len+15)&~15);
806                 skb_put(skb2, len + hlen);
807                 skb2->nh.raw = skb2->data;
808                 skb2->h.raw = skb2->data + hlen;
809                 skb2->protocol = skb->protocol;
810                 skb2->security = skb->security;
811
812                 /*
813                  *      Charge the memory for the fragment to any owner
814                  *      it might possess
815                  */
816
817                 if (skb->sk)
818                         skb_set_owner_w(skb2, skb->sk);
819                 skb2->dst = dst_clone(skb->dst);
820                 skb2->dev = skb->dev;
821
822                 /*
823                  *      Copy the packet header into the new buffer.
824                  */
825
826                 memcpy(skb2->nh.raw, skb->data, hlen);
827
828                 /*
829                  *      Copy a block of the IP datagram.
830                  */
831                 if (skb_copy_bits(skb, ptr, skb2->h.raw, len))
832                         BUG();
833                 left -= len;
834
835                 /*
836                  *      Fill in the new header fields.
837                  */
838                 iph = skb2->nh.iph;
839                 iph->frag_off = htons((offset >> 3));
840
841                 /* ANK: dirty, but effective trick. Upgrade options only if
842                  * the segment to be fragmented was THE FIRST (otherwise,
843                  * options are already fixed) and make it ONCE
844                  * on the initial skb, so that all the following fragments
845                  * will inherit fixed options.
846                  */
847                 if (offset == 0)
848                         ip_options_fragment(skb);
849
850                 /* Copy the flags to each fragment. */
851                 IPCB(skb2)->flags = IPCB(skb)->flags;
852
853                 /*
854                  *      Added AC : If we are fragmenting a fragment that's not the
855                  *                 last fragment then keep MF on each bit
856                  */
857                 if (left > 0 || not_last_frag)
858                         iph->frag_off |= htons(IP_MF);
859                 ptr += len;
860                 offset += len;
861
862 #ifdef CONFIG_NET_SCHED
863                 skb2->tc_index = skb->tc_index;
864 #endif
865 #ifdef CONFIG_NETFILTER
866                 skb2->nfmark = skb->nfmark;
867                 /* Connection association is same as pre-frag packet */
868                 skb2->nfct = skb->nfct;
869                 nf_conntrack_get(skb2->nfct);
870 #ifdef CONFIG_NETFILTER_DEBUG
871                 skb2->nf_debug = skb->nf_debug;
872 #endif
873 #endif
874
875                 /*
876                  *      Put this fragment into the sending queue.
877                  */
878
879                 IP_INC_STATS(IpFragCreates);
880
881                 iph->tot_len = htons(len + hlen);
882
883                 ip_send_check(iph);
884
885                 err = output(skb2);
886                 if (err)
887                         goto fail;
888         }
889         kfree_skb(skb);
890         IP_INC_STATS(IpFragOKs);
891         return err;
892
893 fail:
894         kfree_skb(skb); 
895         IP_INC_STATS(IpFragFails);
896         return err;
897 }
898
899 /*
900  *      Fetch data from kernel space and fill in checksum if needed.
901  */
902 static int ip_reply_glue_bits(const void *dptr, char *to, unsigned int offset, 
903                               unsigned int fraglen)
904 {
905         struct ip_reply_arg *dp = (struct ip_reply_arg*)dptr;
906         u16 *pktp = (u16 *)to;
907         struct iovec *iov; 
908         int len; 
909         int hdrflag = 1; 
910
911         iov = &dp->iov[0]; 
912         if (offset >= iov->iov_len) { 
913                 offset -= iov->iov_len;
914                 iov++; 
915                 hdrflag = 0; 
916         }
917         len = iov->iov_len - offset;
918         if (fraglen > len) { /* overlapping. */ 
919                 dp->csum = csum_partial_copy_nocheck(iov->iov_base+offset, to, len,
920                                              dp->csum);
921                 offset = 0;
922                 fraglen -= len; 
923                 to += len; 
924                 iov++;
925         }
926
927         dp->csum = csum_partial_copy_nocheck(iov->iov_base+offset, to, fraglen, 
928                                              dp->csum); 
929
930         if (hdrflag && dp->csumoffset)
931                 *(pktp + dp->csumoffset) = csum_fold(dp->csum); /* fill in checksum */
932         return 0;              
933 }
934
935 /* 
936  *      Generic function to send a packet as reply to another packet.
937  *      Used to send TCP resets so far. ICMP should use this function too.
938  *
939  *      Should run single threaded per socket because it uses the sock 
940  *      structure to pass arguments.
941  */
942 void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg,
943                    unsigned int len)
944 {
945         struct {
946                 struct ip_options       opt;
947                 char                    data[40];
948         } replyopts;
949         struct ipcm_cookie ipc;
950         u32 daddr;
951         struct rtable *rt = (struct rtable*)skb->dst;
952
953         if (ip_options_echo(&replyopts.opt, skb))
954                 return;
955
956         daddr = ipc.addr = rt->rt_src;
957         ipc.opt = NULL;
958
959         if (replyopts.opt.optlen) {
960                 ipc.opt = &replyopts.opt;
961
962                 if (ipc.opt->srr)
963                         daddr = replyopts.opt.faddr;
964         }
965
966         if (ip_route_output(&rt, daddr, rt->rt_spec_dst, RT_TOS(skb->nh.iph->tos), 0))
967                 return;
968
969         /* And let IP do all the hard work.
970
971            This chunk is not reenterable, hence spinlock.
972            Note that it uses the fact, that this function is called
973            with locally disabled BH and that sk cannot be already spinlocked.
974          */
975         bh_lock_sock(sk);
976         sk->protinfo.af_inet.tos = skb->nh.iph->tos;
977         sk->priority = skb->priority;
978         sk->protocol = skb->nh.iph->protocol;
979         ip_build_xmit(sk, ip_reply_glue_bits, arg, len, &ipc, rt, MSG_DONTWAIT);
980         bh_unlock_sock(sk);
981
982         ip_rt_put(rt);
983 }
984
985 /*
986  *      IP protocol layer initialiser
987  */
988
989 static struct packet_type ip_packet_type =
990 {
991         __constant_htons(ETH_P_IP),
992         NULL,   /* All devices */
993         ip_rcv,
994         (void*)1,
995         NULL,
996 };
997
998 /*
999  *      IP registers the packet type and then calls the subprotocol initialisers
1000  */
1001
1002 void __init ip_init(void)
1003 {
1004         dev_add_pack(&ip_packet_type);
1005
1006         ip_rt_init();
1007         inet_initpeers();
1008
1009 #ifdef CONFIG_IP_MULTICAST
1010         proc_net_create("igmp", 0, ip_mc_procinfo);
1011 #endif
1012 }