?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] slab: minor cleanup to kmem_cache_alloc_node
[linux-2.6/cjktty.git] / net / ipv6 / ip6_output.c
blobefa3e72cfcfa3d536a425d9c466026c46acf5113
1 /*
2 * IPv6 output functions
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * $Id: ip6_output.c,v 1.34 2002/02/01 22:01:04 davem Exp $
9 *
10 * Based on linux/net/ipv4/ip_output.c
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 * Changes:
18 * A.N.Kuznetsov : airthmetics in fragmentation.
19 * extension headers are implemented.
20 * route changes now work.
21 * ip6_forward does not confuse sniffers.
22 * etc.
23 *
24 * H. von Brand : Added missing #include <linux/string.h>
25 * Imran Patel : frag id should be in NBO
26 * Kazunori MIYAZAWA @USAGI
27 * : add ip6_append_data and related functions
28 * for datagram xmit
29 */
30
31 #include <linux/config.h>
32 #include <linux/errno.h>
33 #include <linux/types.h>
34 #include <linux/string.h>
35 #include <linux/socket.h>
36 #include <linux/net.h>
37 #include <linux/netdevice.h>
38 #include <linux/if_arp.h>
39 #include <linux/in6.h>
40 #include <linux/tcp.h>
41 #include <linux/route.h>
42
43 #include <linux/netfilter.h>
44 #include <linux/netfilter_ipv6.h>
45
46 #include <net/sock.h>
47 #include <net/snmp.h>
48
49 #include <net/ipv6.h>
50 #include <net/ndisc.h>
51 #include <net/protocol.h>
52 #include <net/ip6_route.h>
53 #include <net/addrconf.h>
54 #include <net/rawv6.h>
55 #include <net/icmp.h>
56 #include <net/xfrm.h>
57 #include <net/checksum.h>
58
59 static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *));
60
61 static __inline__ void ipv6_select_ident(struct sk_buff *skb, struct frag_hdr *fhdr)
62 {
63 static u32 ipv6_fragmentation_id = 1;
64 static DEFINE_SPINLOCK(ip6_id_lock);
65
66 spin_lock_bh(&ip6_id_lock);
67 fhdr->identification = htonl(ipv6_fragmentation_id);
68 if (++ipv6_fragmentation_id == 0)
69 ipv6_fragmentation_id = 1;
70 spin_unlock_bh(&ip6_id_lock);
71 }
72
73 static inline int ip6_output_finish(struct sk_buff *skb)
74 {
75
76 struct dst_entry *dst = skb->dst;
77 struct hh_cache *hh = dst->hh;
78
79 if (hh) {
80 int hh_alen;
81
82 read_lock_bh(&hh->hh_lock);
83 hh_alen = HH_DATA_ALIGN(hh->hh_len);
84 memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
85 read_unlock_bh(&hh->hh_lock);
86 skb_push(skb, hh->hh_len);
87 return hh->hh_output(skb);
88 } else if (dst->neighbour)
89 return dst->neighbour->output(skb);
90
91 IP6_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
92 kfree_skb(skb);
93 return -EINVAL;
94
95 }
96
97 /* dev_loopback_xmit for use with netfilter. */
98 static int ip6_dev_loopback_xmit(struct sk_buff *newskb)
99 {
100 newskb->mac.raw = newskb->data;
101 __skb_pull(newskb, newskb->nh.raw - newskb->data);
102 newskb->pkt_type = PACKET_LOOPBACK;
103 newskb->ip_summed = CHECKSUM_UNNECESSARY;
104 BUG_TRAP(newskb->dst);
105
106 netif_rx(newskb);
107 return 0;
108 }
109
110
111 static int ip6_output2(struct sk_buff *skb)
112 {
113 struct dst_entry *dst = skb->dst;
114 struct net_device *dev = dst->dev;
115
116 skb->protocol = htons(ETH_P_IPV6);
117 skb->dev = dev;
118
119 if (ipv6_addr_is_multicast(&skb->nh.ipv6h->daddr)) {
120 struct ipv6_pinfo* np = skb->sk ? inet6_sk(skb->sk) : NULL;
121
122 if (!(dev->flags & IFF_LOOPBACK) && (!np || np->mc_loop) &&
123 ipv6_chk_mcast_addr(dev, &skb->nh.ipv6h->daddr,
124 &skb->nh.ipv6h->saddr)) {
125 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
126
127 /* Do not check for IFF_ALLMULTI; multicast routing
128 is not supported in any case.
129 */
130 if (newskb)
131 NF_HOOK(PF_INET6, NF_IP6_POST_ROUTING, newskb, NULL,
132 newskb->dev,
133 ip6_dev_loopback_xmit);
134
135 if (skb->nh.ipv6h->hop_limit == 0) {
136 IP6_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
137 kfree_skb(skb);
138 return 0;
139 }
140 }
141
142 IP6_INC_STATS(IPSTATS_MIB_OUTMCASTPKTS);
143 }
144
145 return NF_HOOK(PF_INET6, NF_IP6_POST_ROUTING, skb,NULL, skb->dev,ip6_output_finish);
146 }
147
148 int ip6_output(struct sk_buff *skb)
149 {
150 if ((skb->len > dst_mtu(skb->dst) && !skb_shinfo(skb)->ufo_size) ||
151 dst_allfrag(skb->dst))
152 return ip6_fragment(skb, ip6_output2);
153 else
154 return ip6_output2(skb);
155 }
156
157 /*
158 * xmit an sk_buff (used by TCP)
159 */
160
161 int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
162 struct ipv6_txoptions *opt, int ipfragok)
163 {
164 struct ipv6_pinfo *np = sk ? inet6_sk(sk) : NULL;
165 struct in6_addr *first_hop = &fl->fl6_dst;
166 struct dst_entry *dst = skb->dst;
167 struct ipv6hdr *hdr;
168 u8 proto = fl->proto;
169 int seg_len = skb->len;
170 int hlimit, tclass;
171 u32 mtu;
172
173 if (opt) {
174 int head_room;
175
176 /* First: exthdrs may take lots of space (~8K for now)
177 MAX_HEADER is not enough.
178 */
179 head_room = opt->opt_nflen + opt->opt_flen;
180 seg_len += head_room;
181 head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);
182
183 if (skb_headroom(skb) < head_room) {
184 struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
185 kfree_skb(skb);
186 skb = skb2;
187 if (skb == NULL) {
188 IP6_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
189 return -ENOBUFS;
190 }
191 if (sk)
192 skb_set_owner_w(skb, sk);
193 }
194 if (opt->opt_flen)
195 ipv6_push_frag_opts(skb, opt, &proto);
196 if (opt->opt_nflen)
197 ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop);
198 }
199
200 hdr = skb->nh.ipv6h = (struct ipv6hdr*)skb_push(skb, sizeof(struct ipv6hdr));
201
202 /*
203 * Fill in the IPv6 header
204 */
205
206 hlimit = -1;
207 if (np)
208 hlimit = np->hop_limit;
209 if (hlimit < 0)
210 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
211 if (hlimit < 0)
212 hlimit = ipv6_get_hoplimit(dst->dev);
213
214 tclass = -1;
215 if (np)
216 tclass = np->tclass;
217 if (tclass < 0)
218 tclass = 0;
219
220 *(u32 *)hdr = htonl(0x60000000 | (tclass << 20)) | fl->fl6_flowlabel;
221
222 hdr->payload_len = htons(seg_len);
223 hdr->nexthdr = proto;
224 hdr->hop_limit = hlimit;
225
226 ipv6_addr_copy(&hdr->saddr, &fl->fl6_src);
227 ipv6_addr_copy(&hdr->daddr, first_hop);
228
229 skb->priority = sk->sk_priority;
230
231 mtu = dst_mtu(dst);
232 if ((skb->len <= mtu) || ipfragok) {
233 IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
234 return NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev,
235 dst_output);
236 }
237
238 if (net_ratelimit())
239 printk(KERN_DEBUG "IPv6: sending pkt_too_big to self\n");
240 skb->dev = dst->dev;
241 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, skb->dev);
242 IP6_INC_STATS(IPSTATS_MIB_FRAGFAILS);
243 kfree_skb(skb);
244 return -EMSGSIZE;
245 }
246
247 /*
248 * To avoid extra problems ND packets are send through this
249 * routine. It's code duplication but I really want to avoid
250 * extra checks since ipv6_build_header is used by TCP (which
251 * is for us performance critical)
252 */
253
254 int ip6_nd_hdr(struct sock *sk, struct sk_buff *skb, struct net_device *dev,
255 struct in6_addr *saddr, struct in6_addr *daddr,
256 int proto, int len)
257 {
258 struct ipv6_pinfo *np = inet6_sk(sk);
259 struct ipv6hdr *hdr;
260 int totlen;
261
262 skb->protocol = htons(ETH_P_IPV6);
263 skb->dev = dev;
264
265 totlen = len + sizeof(struct ipv6hdr);
266
267 hdr = (struct ipv6hdr *) skb_put(skb, sizeof(struct ipv6hdr));
268 skb->nh.ipv6h = hdr;
269
270 *(u32*)hdr = htonl(0x60000000);
271
272 hdr->payload_len = htons(len);
273 hdr->nexthdr = proto;
274 hdr->hop_limit = np->hop_limit;
275
276 ipv6_addr_copy(&hdr->saddr, saddr);
277 ipv6_addr_copy(&hdr->daddr, daddr);
278
279 return 0;
280 }
281
282 static int ip6_call_ra_chain(struct sk_buff *skb, int sel)
283 {
284 struct ip6_ra_chain *ra;
285 struct sock *last = NULL;
286
287 read_lock(&ip6_ra_lock);
288 for (ra = ip6_ra_chain; ra; ra = ra->next) {
289 struct sock *sk = ra->sk;
290 if (sk && ra->sel == sel &&
291 (!sk->sk_bound_dev_if ||
292 sk->sk_bound_dev_if == skb->dev->ifindex)) {
293 if (last) {
294 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
295 if (skb2)
296 rawv6_rcv(last, skb2);
297 }
298 last = sk;
299 }
300 }
301
302 if (last) {
303 rawv6_rcv(last, skb);
304 read_unlock(&ip6_ra_lock);
305 return 1;
306 }
307 read_unlock(&ip6_ra_lock);
308 return 0;
309 }
310
311 static inline int ip6_forward_finish(struct sk_buff *skb)
312 {
313 return dst_output(skb);
314 }
315
316 int ip6_forward(struct sk_buff *skb)
317 {
318 struct dst_entry *dst = skb->dst;
319 struct ipv6hdr *hdr = skb->nh.ipv6h;
320 struct inet6_skb_parm *opt = IP6CB(skb);
321
322 if (ipv6_devconf.forwarding == 0)
323 goto error;
324
325 if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) {
326 IP6_INC_STATS(IPSTATS_MIB_INDISCARDS);
327 goto drop;
328 }
329
330 skb->ip_summed = CHECKSUM_NONE;
331
332 /*
333 * We DO NOT make any processing on
334 * RA packets, pushing them to user level AS IS
335 * without ane WARRANTY that application will be able
336 * to interpret them. The reason is that we
337 * cannot make anything clever here.
338 *
339 * We are not end-node, so that if packet contains
340 * AH/ESP, we cannot make anything.
341 * Defragmentation also would be mistake, RA packets
342 * cannot be fragmented, because there is no warranty
343 * that different fragments will go along one path. --ANK
344 */
345 if (opt->ra) {
346 u8 *ptr = skb->nh.raw + opt->ra;
347 if (ip6_call_ra_chain(skb, (ptr[2]<<8) + ptr[3]))
348 return 0;
349 }
350
351 /*
352 * check and decrement ttl
353 */
354 if (hdr->hop_limit <= 1) {
355 /* Force OUTPUT device used as source address */
356 skb->dev = dst->dev;
357 icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
358 0, skb->dev);
359
360 kfree_skb(skb);
361 return -ETIMEDOUT;
362 }
363
364 if (!xfrm6_route_forward(skb)) {
365 IP6_INC_STATS(IPSTATS_MIB_INDISCARDS);
366 goto drop;
367 }
368 dst = skb->dst;
369
370 /* IPv6 specs say nothing about it, but it is clear that we cannot
371 send redirects to source routed frames.
372 */
373 if (skb->dev == dst->dev && dst->neighbour && opt->srcrt == 0) {
374 struct in6_addr *target = NULL;
375 struct rt6_info *rt;
376 struct neighbour *n = dst->neighbour;
377
378 /*
379 * incoming and outgoing devices are the same
380 * send a redirect.
381 */
382
383 rt = (struct rt6_info *) dst;
384 if ((rt->rt6i_flags & RTF_GATEWAY))
385 target = (struct in6_addr*)&n->primary_key;
386 else
387 target = &hdr->daddr;
388
389 /* Limit redirects both by destination (here)
390 and by source (inside ndisc_send_redirect)
391 */
392 if (xrlim_allow(dst, 1*HZ))
393 ndisc_send_redirect(skb, n, target);
394 } else if (ipv6_addr_type(&hdr->saddr)&(IPV6_ADDR_MULTICAST|IPV6_ADDR_LOOPBACK
395 |IPV6_ADDR_LINKLOCAL)) {
396 /* This check is security critical. */
397 goto error;
398 }
399
400 if (skb->len > dst_mtu(dst)) {
401 /* Again, force OUTPUT device used as source address */
402 skb->dev = dst->dev;
403 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, dst_mtu(dst), skb->dev);
404 IP6_INC_STATS_BH(IPSTATS_MIB_INTOOBIGERRORS);
405 IP6_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
406 kfree_skb(skb);
407 return -EMSGSIZE;
408 }
409
410 if (skb_cow(skb, dst->dev->hard_header_len)) {
411 IP6_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
412 goto drop;
413 }
414
415 hdr = skb->nh.ipv6h;
416
417 /* Mangling hops number delayed to point after skb COW */
418
419 hdr->hop_limit--;
420
421 IP6_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
422 return NF_HOOK(PF_INET6,NF_IP6_FORWARD, skb, skb->dev, dst->dev, ip6_forward_finish);
423
424 error:
425 IP6_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
426 drop:
427 kfree_skb(skb);
428 return -EINVAL;
429 }
430
431 static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
432 {
433 to->pkt_type = from->pkt_type;
434 to->priority = from->priority;
435 to->protocol = from->protocol;
436 dst_release(to->dst);
437 to->dst = dst_clone(from->dst);
438 to->dev = from->dev;
439
440 #ifdef CONFIG_NET_SCHED
441 to->tc_index = from->tc_index;
442 #endif
443 #ifdef CONFIG_NETFILTER
444 to->nfmark = from->nfmark;
445 /* Connection association is same as pre-frag packet */
446 nf_conntrack_put(to->nfct);
447 to->nfct = from->nfct;
448 nf_conntrack_get(to->nfct);
449 to->nfctinfo = from->nfctinfo;
450 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
451 nf_conntrack_put_reasm(to->nfct_reasm);
452 to->nfct_reasm = from->nfct_reasm;
453 nf_conntrack_get_reasm(to->nfct_reasm);
454 #endif
455 #ifdef CONFIG_BRIDGE_NETFILTER
456 nf_bridge_put(to->nf_bridge);
457 to->nf_bridge = from->nf_bridge;
458 nf_bridge_get(to->nf_bridge);
459 #endif
460 #endif
461 }
462
463 int ip6_find_1stfragopt(struct sk_buff *skb, u8 **nexthdr)
464 {
465 u16 offset = sizeof(struct ipv6hdr);
466 struct ipv6_opt_hdr *exthdr = (struct ipv6_opt_hdr*)(skb->nh.ipv6h + 1);
467 unsigned int packet_len = skb->tail - skb->nh.raw;
468 int found_rhdr = 0;
469 *nexthdr = &skb->nh.ipv6h->nexthdr;
470
471 while (offset + 1 <= packet_len) {
472
473 switch (**nexthdr) {
474
475 case NEXTHDR_HOP:
476 case NEXTHDR_ROUTING:
477 case NEXTHDR_DEST:
478 if (**nexthdr == NEXTHDR_ROUTING) found_rhdr = 1;
479 if (**nexthdr == NEXTHDR_DEST && found_rhdr) return offset;
480 offset += ipv6_optlen(exthdr);
481 *nexthdr = &exthdr->nexthdr;
482 exthdr = (struct ipv6_opt_hdr*)(skb->nh.raw + offset);
483 break;
484 default :
485 return offset;
486 }
487 }
488
489 return offset;
490 }
491
492 static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
493 {
494 struct net_device *dev;
495 struct sk_buff *frag;
496 struct rt6_info *rt = (struct rt6_info*)skb->dst;
497 struct ipv6hdr *tmp_hdr;
498 struct frag_hdr *fh;
499 unsigned int mtu, hlen, left, len;
500 u32 frag_id = 0;
501 int ptr, offset = 0, err=0;
502 u8 *prevhdr, nexthdr = 0;
503
504 dev = rt->u.dst.dev;
505 hlen = ip6_find_1stfragopt(skb, &prevhdr);
506 nexthdr = *prevhdr;
507
508 mtu = dst_mtu(&rt->u.dst) - hlen - sizeof(struct frag_hdr);
509
510 if (skb_shinfo(skb)->frag_list) {
511 int first_len = skb_pagelen(skb);
512
513 if (first_len - hlen > mtu ||
514 ((first_len - hlen) & 7) ||
515 skb_cloned(skb))
516 goto slow_path;
517
518 for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
519 /* Correct geometry. */
520 if (frag->len > mtu ||
521 ((frag->len & 7) && frag->next) ||
522 skb_headroom(frag) < hlen)
523 goto slow_path;
524
525 /* Partially cloned skb? */
526 if (skb_shared(frag))
527 goto slow_path;
528
529 BUG_ON(frag->sk);
530 if (skb->sk) {
531 sock_hold(skb->sk);
532 frag->sk = skb->sk;
533 frag->destructor = sock_wfree;
534 skb->truesize -= frag->truesize;
535 }
536 }
537
538 err = 0;
539 offset = 0;
540 frag = skb_shinfo(skb)->frag_list;
541 skb_shinfo(skb)->frag_list = NULL;
542 /* BUILD HEADER */
543
544 tmp_hdr = kmalloc(hlen, GFP_ATOMIC);
545 if (!tmp_hdr) {
546 IP6_INC_STATS(IPSTATS_MIB_FRAGFAILS);
547 return -ENOMEM;
548 }
549
550 *prevhdr = NEXTHDR_FRAGMENT;
551 memcpy(tmp_hdr, skb->nh.raw, hlen);
552 __skb_pull(skb, hlen);
553 fh = (struct frag_hdr*)__skb_push(skb, sizeof(struct frag_hdr));
554 skb->nh.raw = __skb_push(skb, hlen);
555 memcpy(skb->nh.raw, tmp_hdr, hlen);
556
557 ipv6_select_ident(skb, fh);
558 fh->nexthdr = nexthdr;
559 fh->reserved = 0;
560 fh->frag_off = htons(IP6_MF);
561 frag_id = fh->identification;
562
563 first_len = skb_pagelen(skb);
564 skb->data_len = first_len - skb_headlen(skb);
565 skb->len = first_len;
566 skb->nh.ipv6h->payload_len = htons(first_len - sizeof(struct ipv6hdr));
567
568
569 for (;;) {
570 /* Prepare header of the next frame,
571 * before previous one went down. */
572 if (frag) {
573 frag->ip_summed = CHECKSUM_NONE;
574 frag->h.raw = frag->data;
575 fh = (struct frag_hdr*)__skb_push(frag, sizeof(struct frag_hdr));
576 frag->nh.raw = __skb_push(frag, hlen);
577 memcpy(frag->nh.raw, tmp_hdr, hlen);
578 offset += skb->len - hlen - sizeof(struct frag_hdr);
579 fh->nexthdr = nexthdr;
580 fh->reserved = 0;
581 fh->frag_off = htons(offset);
582 if (frag->next != NULL)
583 fh->frag_off |= htons(IP6_MF);
584 fh->identification = frag_id;
585 frag->nh.ipv6h->payload_len = htons(frag->len - sizeof(struct ipv6hdr));
586 ip6_copy_metadata(frag, skb);
587 }
588
589 err = output(skb);
590 if (err || !frag)
591 break;
592
593 skb = frag;
594 frag = skb->next;
595 skb->next = NULL;
596 }
597
598 kfree(tmp_hdr);
599
600 if (err == 0) {
601 IP6_INC_STATS(IPSTATS_MIB_FRAGOKS);
602 return 0;
603 }
604
605 while (frag) {
606 skb = frag->next;
607 kfree_skb(frag);
608 frag = skb;
609 }
610
611 IP6_INC_STATS(IPSTATS_MIB_FRAGFAILS);
612 return err;
613 }
614
615 slow_path:
616 left = skb->len - hlen; /* Space per frame */
617 ptr = hlen; /* Where to start from */
618
619 /*
620 * Fragment the datagram.
621 */
622
623 *prevhdr = NEXTHDR_FRAGMENT;
624
625 /*
626 * Keep copying data until we run out.
627 */
628 while(left > 0) {
629 len = left;
630 /* IF: it doesn't fit, use 'mtu' - the data space left */
631 if (len > mtu)
632 len = mtu;
633 /* IF: we are not sending upto and including the packet end
634 then align the next start on an eight byte boundary */
635 if (len < left) {
636 len &= ~7;
637 }
638 /*
639 * Allocate buffer.
640 */
641
642 if ((frag = alloc_skb(len+hlen+sizeof(struct frag_hdr)+LL_RESERVED_SPACE(rt->u.dst.dev), GFP_ATOMIC)) == NULL) {
643 NETDEBUG(KERN_INFO "IPv6: frag: no memory for new fragment!\n");
644 IP6_INC_STATS(IPSTATS_MIB_FRAGFAILS);
645 err = -ENOMEM;
646 goto fail;
647 }
648
649 /*
650 * Set up data on packet
651 */
652
653 ip6_copy_metadata(frag, skb);
654 skb_reserve(frag, LL_RESERVED_SPACE(rt->u.dst.dev));
655 skb_put(frag, len + hlen + sizeof(struct frag_hdr));
656 frag->nh.raw = frag->data;
657 fh = (struct frag_hdr*)(frag->data + hlen);
658 frag->h.raw = frag->data + hlen + sizeof(struct frag_hdr);
659
660 /*
661 * Charge the memory for the fragment to any owner
662 * it might possess
663 */
664 if (skb->sk)
665 skb_set_owner_w(frag, skb->sk);
666
667 /*
668 * Copy the packet header into the new buffer.
669 */
670 memcpy(frag->nh.raw, skb->data, hlen);
671
672 /*
673 * Build fragment header.
674 */
675 fh->nexthdr = nexthdr;
676 fh->reserved = 0;
677 if (!frag_id) {
678 ipv6_select_ident(skb, fh);
679 frag_id = fh->identification;
680 } else
681 fh->identification = frag_id;
682
683 /*
684 * Copy a block of the IP datagram.
685 */
686 if (skb_copy_bits(skb, ptr, frag->h.raw, len))
687 BUG();
688 left -= len;
689
690 fh->frag_off = htons(offset);
691 if (left > 0)
692 fh->frag_off |= htons(IP6_MF);
693 frag->nh.ipv6h->payload_len = htons(frag->len - sizeof(struct ipv6hdr));
694
695 ptr += len;
696 offset += len;
697
698 /*
699 * Put this fragment into the sending queue.
700 */
701
702 IP6_INC_STATS(IPSTATS_MIB_FRAGCREATES);
703
704 err = output(frag);
705 if (err)
706 goto fail;
707 }
708 kfree_skb(skb);
709 IP6_INC_STATS(IPSTATS_MIB_FRAGOKS);
710 return err;
711
712 fail:
713 kfree_skb(skb);
714 IP6_INC_STATS(IPSTATS_MIB_FRAGFAILS);
715 return err;
716 }
717
718 int ip6_dst_lookup(struct sock *sk, struct dst_entry **dst, struct flowi *fl)
719 {
720 int err = 0;
721
722 *dst = NULL;
723 if (sk) {
724 struct ipv6_pinfo *np = inet6_sk(sk);
725
726 *dst = sk_dst_check(sk, np->dst_cookie);
727 if (*dst) {
728 struct rt6_info *rt = (struct rt6_info*)*dst;
729
730 /* Yes, checking route validity in not connected
731 case is not very simple. Take into account,
732 that we do not support routing by source, TOS,
733 and MSG_DONTROUTE --ANK (980726)
734
735 1. If route was host route, check that
736 cached destination is current.
737 If it is network route, we still may
738 check its validity using saved pointer
739 to the last used address: daddr_cache.
740 We do not want to save whole address now,
741 (because main consumer of this service
742 is tcp, which has not this problem),
743 so that the last trick works only on connected
744 sockets.
745 2. oif also should be the same.
746 */
747
748 if (((rt->rt6i_dst.plen != 128 ||
749 !ipv6_addr_equal(&fl->fl6_dst, &rt->rt6i_dst.addr))
750 && (np->daddr_cache == NULL ||
751 !ipv6_addr_equal(&fl->fl6_dst, np->daddr_cache)))
752 || (fl->oif && fl->oif != (*dst)->dev->ifindex)) {
753 dst_release(*dst);
754 *dst = NULL;
755 }
756 }
757 }
758
759 if (*dst == NULL)
760 *dst = ip6_route_output(sk, fl);
761
762 if ((err = (*dst)->error))
763 goto out_err_release;
764
765 if (ipv6_addr_any(&fl->fl6_src)) {
766 err = ipv6_get_saddr(*dst, &fl->fl6_dst, &fl->fl6_src);
767
768 if (err)
769 goto out_err_release;
770 }
771
772 return 0;
773
774 out_err_release:
775 dst_release(*dst);
776 *dst = NULL;
777 return err;
778 }
779
780 EXPORT_SYMBOL_GPL(ip6_dst_lookup);
781
782 static inline int ip6_ufo_append_data(struct sock *sk,
783 int getfrag(void *from, char *to, int offset, int len,
784 int odd, struct sk_buff *skb),
785 void *from, int length, int hh_len, int fragheaderlen,
786 int transhdrlen, int mtu,unsigned int flags)
787
788 {
789 struct sk_buff *skb;
790 int err;
791
792 /* There is support for UDP large send offload by network
793 * device, so create one single skb packet containing complete
794 * udp datagram
795 */
796 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) {
797 skb = sock_alloc_send_skb(sk,
798 hh_len + fragheaderlen + transhdrlen + 20,
799 (flags & MSG_DONTWAIT), &err);
800 if (skb == NULL)
801 return -ENOMEM;
802
803 /* reserve space for Hardware header */
804 skb_reserve(skb, hh_len);
805
806 /* create space for UDP/IP header */
807 skb_put(skb,fragheaderlen + transhdrlen);
808
809 /* initialize network header pointer */
810 skb->nh.raw = skb->data;
811
812 /* initialize protocol header pointer */
813 skb->h.raw = skb->data + fragheaderlen;
814
815 skb->ip_summed = CHECKSUM_HW;
816 skb->csum = 0;
817 sk->sk_sndmsg_off = 0;
818 }
819
820 err = skb_append_datato_frags(sk,skb, getfrag, from,
821 (length - transhdrlen));
822 if (!err) {
823 struct frag_hdr fhdr;
824
825 /* specify the length of each IP datagram fragment*/
826 skb_shinfo(skb)->ufo_size = (mtu - fragheaderlen) -
827 sizeof(struct frag_hdr);
828 ipv6_select_ident(skb, &fhdr);
829 skb_shinfo(skb)->ip6_frag_id = fhdr.identification;
830 __skb_queue_tail(&sk->sk_write_queue, skb);
831
832 return 0;
833 }
834 /* There is not enough support do UPD LSO,
835 * so follow normal path
836 */
837 kfree_skb(skb);
838
839 return err;
840 }
841
842 int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to,
843 int offset, int len, int odd, struct sk_buff *skb),
844 void *from, int length, int transhdrlen,
845 int hlimit, int tclass, struct ipv6_txoptions *opt, struct flowi *fl,
846 struct rt6_info *rt, unsigned int flags)
847 {
848 struct inet_sock *inet = inet_sk(sk);
849 struct ipv6_pinfo *np = inet6_sk(sk);
850 struct sk_buff *skb;
851 unsigned int maxfraglen, fragheaderlen;
852 int exthdrlen;
853 int hh_len;
854 int mtu;
855 int copy;
856 int err;
857 int offset = 0;
858 int csummode = CHECKSUM_NONE;
859
860 if (flags&MSG_PROBE)
861 return 0;
862 if (skb_queue_empty(&sk->sk_write_queue)) {
863 /*
864 * setup for corking
865 */
866 if (opt) {
867 if (np->cork.opt == NULL) {
868 np->cork.opt = kmalloc(opt->tot_len,
869 sk->sk_allocation);
870 if (unlikely(np->cork.opt == NULL))
871 return -ENOBUFS;
872 } else if (np->cork.opt->tot_len < opt->tot_len) {
873 printk(KERN_DEBUG "ip6_append_data: invalid option length\n");
874 return -EINVAL;
875 }
876 memcpy(np->cork.opt, opt, opt->tot_len);
877 inet->cork.flags |= IPCORK_OPT;
878 /* need source address above miyazawa*/
879 }
880 dst_hold(&rt->u.dst);
881 np->cork.rt = rt;
882 inet->cork.fl = *fl;
883 np->cork.hop_limit = hlimit;
884 np->cork.tclass = tclass;
885 inet->cork.fragsize = mtu = dst_mtu(rt->u.dst.path);
886 if (dst_allfrag(rt->u.dst.path))
887 inet->cork.flags |= IPCORK_ALLFRAG;
888 inet->cork.length = 0;
889 sk->sk_sndmsg_page = NULL;
890 sk->sk_sndmsg_off = 0;
891 exthdrlen = rt->u.dst.header_len + (opt ? opt->opt_flen : 0);
892 length += exthdrlen;
893 transhdrlen += exthdrlen;
894 } else {
895 rt = np->cork.rt;
896 fl = &inet->cork.fl;
897 if (inet->cork.flags & IPCORK_OPT)
898 opt = np->cork.opt;
899 transhdrlen = 0;
900 exthdrlen = 0;
901 mtu = inet->cork.fragsize;
902 }
903
904 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);
905
906 fragheaderlen = sizeof(struct ipv6hdr) + (opt ? opt->opt_nflen : 0);
907 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen - sizeof(struct frag_hdr);
908
909 if (mtu <= sizeof(struct ipv6hdr) + IPV6_MAXPLEN) {
910 if (inet->cork.length + length > sizeof(struct ipv6hdr) + IPV6_MAXPLEN - fragheaderlen) {
911 ipv6_local_error(sk, EMSGSIZE, fl, mtu-exthdrlen);
912 return -EMSGSIZE;
913 }
914 }
915
916 /*
917 * Let's try using as much space as possible.
918 * Use MTU if total length of the message fits into the MTU.
919 * Otherwise, we need to reserve fragment header and
920 * fragment alignment (= 8-15 octects, in total).
921 *
922 * Note that we may need to "move" the data from the tail of
923 * of the buffer to the new fragment when we split
924 * the message.
925 *
926 * FIXME: It may be fragmented into multiple chunks
927 * at once if non-fragmentable extension headers
928 * are too large.
929 * --yoshfuji
930 */
931
932 inet->cork.length += length;
933 if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) &&
934 (rt->u.dst.dev->features & NETIF_F_UFO)) {
935
936 if(ip6_ufo_append_data(sk, getfrag, from, length, hh_len,
937 fragheaderlen, transhdrlen, mtu, flags))
938 goto error;
939
940 return 0;
941 }
942
943 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
944 goto alloc_new_skb;
945
946 while (length > 0) {
947 /* Check if the remaining data fits into current packet. */
948 copy = (inet->cork.length <= mtu && !(inet->cork.flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len;
949 if (copy < length)
950 copy = maxfraglen - skb->len;
951
952 if (copy <= 0) {
953 char *data;
954 unsigned int datalen;
955 unsigned int fraglen;
956 unsigned int fraggap;
957 unsigned int alloclen;
958 struct sk_buff *skb_prev;
959 alloc_new_skb:
960 skb_prev = skb;
961
962 /* There's no room in the current skb */
963 if (skb_prev)
964 fraggap = skb_prev->len - maxfraglen;
965 else
966 fraggap = 0;
967
968 /*
969 * If remaining data exceeds the mtu,
970 * we know we need more fragment(s).
971 */
972 datalen = length + fraggap;
973 if (datalen > (inet->cork.length <= mtu && !(inet->cork.flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen)
974 datalen = maxfraglen - fragheaderlen;
975
976 fraglen = datalen + fragheaderlen;
977 if ((flags & MSG_MORE) &&
978 !(rt->u.dst.dev->features&NETIF_F_SG))
979 alloclen = mtu;
980 else
981 alloclen = datalen + fragheaderlen;
982
983 /*
984 * The last fragment gets additional space at tail.
985 * Note: we overallocate on fragments with MSG_MODE
986 * because we have no idea if we're the last one.
987 */
988 if (datalen == length + fraggap)
989 alloclen += rt->u.dst.trailer_len;
990
991 /*
992 * We just reserve space for fragment header.
993 * Note: this may be overallocation if the message
994 * (without MSG_MORE) fits into the MTU.
995 */
996 alloclen += sizeof(struct frag_hdr);
997
998 if (transhdrlen) {
999 skb = sock_alloc_send_skb(sk,
1000 alloclen + hh_len,
1001 (flags & MSG_DONTWAIT), &err);
1002 } else {
1003 skb = NULL;
1004 if (atomic_read(&sk->sk_wmem_alloc) <=
1005 2 * sk->sk_sndbuf)
1006 skb = sock_wmalloc(sk,
1007 alloclen + hh_len, 1,
1008 sk->sk_allocation);
1009 if (unlikely(skb == NULL))
1010 err = -ENOBUFS;
1011 }
1012 if (skb == NULL)
1013 goto error;
1014 /*
1015 * Fill in the control structures
1016 */
1017 skb->ip_summed = csummode;
1018 skb->csum = 0;
1019 /* reserve for fragmentation */
1020 skb_reserve(skb, hh_len+sizeof(struct frag_hdr));
1021
1022 /*
1023 * Find where to start putting bytes
1024 */
1025 data = skb_put(skb, fraglen);
1026 skb->nh.raw = data + exthdrlen;
1027 data += fragheaderlen;
1028 skb->h.raw = data + exthdrlen;
1029
1030 if (fraggap) {
1031 skb->csum = skb_copy_and_csum_bits(
1032 skb_prev, maxfraglen,
1033 data + transhdrlen, fraggap, 0);
1034 skb_prev->csum = csum_sub(skb_prev->csum,
1035 skb->csum);
1036 data += fraggap;
1037 skb_trim(skb_prev, maxfraglen);
1038 }
1039 copy = datalen - transhdrlen - fraggap;
1040 if (copy < 0) {
1041 err = -EINVAL;
1042 kfree_skb(skb);
1043 goto error;
1044 } else if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
1045 err = -EFAULT;
1046 kfree_skb(skb);
1047 goto error;
1048 }
1049
1050 offset += copy;
1051 length -= datalen - fraggap;
1052 transhdrlen = 0;
1053 exthdrlen = 0;
1054 csummode = CHECKSUM_NONE;
1055
1056 /*
1057 * Put the packet on the pending queue
1058 */
1059 __skb_queue_tail(&sk->sk_write_queue, skb);
1060 continue;
1061 }
1062
1063 if (copy > length)
1064 copy = length;
1065
1066 if (!(rt->u.dst.dev->features&NETIF_F_SG)) {
1067 unsigned int off;
1068
1069 off = skb->len;
1070 if (getfrag(from, skb_put(skb, copy),
1071 offset, copy, off, skb) < 0) {
1072 __skb_trim(skb, off);
1073 err = -EFAULT;
1074 goto error;
1075 }
1076 } else {
1077 int i = skb_shinfo(skb)->nr_frags;
1078 skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
1079 struct page *page = sk->sk_sndmsg_page;
1080 int off = sk->sk_sndmsg_off;
1081 unsigned int left;
1082
1083 if (page && (left = PAGE_SIZE - off) > 0) {
1084 if (copy >= left)
1085 copy = left;
1086 if (page != frag->page) {
1087 if (i == MAX_SKB_FRAGS) {
1088 err = -EMSGSIZE;
1089 goto error;
1090 }
1091 get_page(page);
1092 skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0);
1093 frag = &skb_shinfo(skb)->frags[i];
1094 }
1095 } else if(i < MAX_SKB_FRAGS) {
1096 if (copy > PAGE_SIZE)
1097 copy = PAGE_SIZE;
1098 page = alloc_pages(sk->sk_allocation, 0);
1099 if (page == NULL) {
1100 err = -ENOMEM;
1101 goto error;
1102 }
1103 sk->sk_sndmsg_page = page;
1104 sk->sk_sndmsg_off = 0;
1105
1106 skb_fill_page_desc(skb, i, page, 0, 0);
1107 frag = &skb_shinfo(skb)->frags[i];
1108 skb->truesize += PAGE_SIZE;
1109 atomic_add(PAGE_SIZE, &sk->sk_wmem_alloc);
1110 } else {
1111 err = -EMSGSIZE;
1112 goto error;
1113 }
1114 if (getfrag(from, page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) {
1115 err = -EFAULT;
1116 goto error;
1117 }
1118 sk->sk_sndmsg_off += copy;
1119 frag->size += copy;
1120 skb->len += copy;
1121 skb->data_len += copy;
1122 }
1123 offset += copy;
1124 length -= copy;
1125 }
1126 return 0;
1127 error:
1128 inet->cork.length -= length;
1129 IP6_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
1130 return err;
1131 }
1132
1133 int ip6_push_pending_frames(struct sock *sk)
1134 {
1135 struct sk_buff *skb, *tmp_skb;
1136 struct sk_buff **tail_skb;
1137 struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;
1138 struct inet_sock *inet = inet_sk(sk);
1139 struct ipv6_pinfo *np = inet6_sk(sk);
1140 struct ipv6hdr *hdr;
1141 struct ipv6_txoptions *opt = np->cork.opt;
1142 struct rt6_info *rt = np->cork.rt;
1143 struct flowi *fl = &inet->cork.fl;
1144 unsigned char proto = fl->proto;
1145 int err = 0;
1146
1147 if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)
1148 goto out;
1149 tail_skb = &(skb_shinfo(skb)->frag_list);
1150
1151 /* move skb->data to ip header from ext header */
1152 if (skb->data < skb->nh.raw)
1153 __skb_pull(skb, skb->nh.raw - skb->data);
1154 while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
1155 __skb_pull(tmp_skb, skb->h.raw - skb->nh.raw);
1156 *tail_skb = tmp_skb;
1157 tail_skb = &(tmp_skb->next);
1158 skb->len += tmp_skb->len;
1159 skb->data_len += tmp_skb->len;
1160 skb->truesize += tmp_skb->truesize;
1161 __sock_put(tmp_skb->sk);
1162 tmp_skb->destructor = NULL;
1163 tmp_skb->sk = NULL;
1164 }
1165
1166 ipv6_addr_copy(final_dst, &fl->fl6_dst);
1167 __skb_pull(skb, skb->h.raw - skb->nh.raw);
1168 if (opt && opt->opt_flen)
1169 ipv6_push_frag_opts(skb, opt, &proto);
1170 if (opt && opt->opt_nflen)
1171 ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst);
1172
1173 skb->nh.ipv6h = hdr = (struct ipv6hdr*) skb_push(skb, sizeof(struct ipv6hdr));
1174
1175 *(u32*)hdr = fl->fl6_flowlabel |
1176 htonl(0x60000000 | ((int)np->cork.tclass << 20));
1177
1178 if (skb->len <= sizeof(struct ipv6hdr) + IPV6_MAXPLEN)
1179 hdr->payload_len = htons(skb->len - sizeof(struct ipv6hdr));
1180 else
1181 hdr->payload_len = 0;
1182 hdr->hop_limit = np->cork.hop_limit;
1183 hdr->nexthdr = proto;
1184 ipv6_addr_copy(&hdr->saddr, &fl->fl6_src);
1185 ipv6_addr_copy(&hdr->daddr, final_dst);
1186
1187 skb->priority = sk->sk_priority;
1188
1189 skb->dst = dst_clone(&rt->u.dst);
1190 IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);
1191 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, skb->dst->dev, dst_output);
1192 if (err) {
1193 if (err > 0)
1194 err = np->recverr ? net_xmit_errno(err) : 0;
1195 if (err)
1196 goto error;
1197 }
1198
1199 out:
1200 inet->cork.flags &= ~IPCORK_OPT;
1201 kfree(np->cork.opt);
1202 np->cork.opt = NULL;
1203 if (np->cork.rt) {
1204 dst_release(&np->cork.rt->u.dst);
1205 np->cork.rt = NULL;
1206 inet->cork.flags &= ~IPCORK_ALLFRAG;
1207 }
1208 memset(&inet->cork.fl, 0, sizeof(inet->cork.fl));
1209 return err;
1210 error:
1211 goto out;
1212 }
1213
1214 void ip6_flush_pending_frames(struct sock *sk)
1215 {
1216 struct inet_sock *inet = inet_sk(sk);
1217 struct ipv6_pinfo *np = inet6_sk(sk);
1218 struct sk_buff *skb;
1219
1220 while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) {
1221 IP6_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
1222 kfree_skb(skb);
1223 }
1224
1225 inet->cork.flags &= ~IPCORK_OPT;
1226
1227 kfree(np->cork.opt);
1228 np->cork.opt = NULL;
1229 if (np->cork.rt) {
1230 dst_release(&np->cork.rt->u.dst);
1231 np->cork.rt = NULL;
1232 inet->cork.flags &= ~IPCORK_ALLFRAG;
1233 }
1234 memset(&inet->cork.fl, 0, sizeof(inet->cork.fl));
1235 }
CJK support for tty framebuffer vt