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