]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - net/ipv6/ip6_output.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ipv6: added net argument to ICMP6MSGOUT_INC_STATS
[mirror_ubuntu-artful-kernel.git] / net / ipv6 / ip6_output.c
1 /*
2 * IPv6 output functions
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * Based on linux/net/ipv4/ip_output.c
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 *
15 * Changes:
16 * A.N.Kuznetsov : airthmetics in fragmentation.
17 * extension headers are implemented.
18 * route changes now work.
19 * ip6_forward does not confuse sniffers.
20 * etc.
21 *
22 * H. von Brand : Added missing #include <linux/string.h>
23 * Imran Patel : frag id should be in NBO
24 * Kazunori MIYAZAWA @USAGI
25 * : add ip6_append_data and related functions
26 * for datagram xmit
27 */
28
29 #include <linux/errno.h>
30 #include <linux/kernel.h>
31 #include <linux/string.h>
32 #include <linux/socket.h>
33 #include <linux/net.h>
34 #include <linux/netdevice.h>
35 #include <linux/if_arp.h>
36 #include <linux/in6.h>
37 #include <linux/tcp.h>
38 #include <linux/route.h>
39 #include <linux/module.h>
40
41 #include <linux/netfilter.h>
42 #include <linux/netfilter_ipv6.h>
43
44 #include <net/sock.h>
45 #include <net/snmp.h>
46
47 #include <net/ipv6.h>
48 #include <net/ndisc.h>
49 #include <net/protocol.h>
50 #include <net/ip6_route.h>
51 #include <net/addrconf.h>
52 #include <net/rawv6.h>
53 #include <net/icmp.h>
54 #include <net/xfrm.h>
55 #include <net/checksum.h>
56 #include <linux/mroute6.h>
57
58 static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *));
59
60 static __inline__ void ipv6_select_ident(struct sk_buff *skb, struct frag_hdr *fhdr)
61 {
62 static u32 ipv6_fragmentation_id = 1;
63 static DEFINE_SPINLOCK(ip6_id_lock);
64
65 spin_lock_bh(&ip6_id_lock);
66 fhdr->identification = htonl(ipv6_fragmentation_id);
67 if (++ipv6_fragmentation_id == 0)
68 ipv6_fragmentation_id = 1;
69 spin_unlock_bh(&ip6_id_lock);
70 }
71
72 int __ip6_local_out(struct sk_buff *skb)
73 {
74 int len;
75
76 len = skb->len - sizeof(struct ipv6hdr);
77 if (len > IPV6_MAXPLEN)
78 len = 0;
79 ipv6_hdr(skb)->payload_len = htons(len);
80
81 return nf_hook(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, skb->dst->dev,
82 dst_output);
83 }
84
85 int ip6_local_out(struct sk_buff *skb)
86 {
87 int err;
88
89 err = __ip6_local_out(skb);
90 if (likely(err == 1))
91 err = dst_output(skb);
92
93 return err;
94 }
95 EXPORT_SYMBOL_GPL(ip6_local_out);
96
97 static int ip6_output_finish(struct sk_buff *skb)
98 {
99 struct dst_entry *dst = skb->dst;
100
101 if (dst->hh)
102 return neigh_hh_output(dst->hh, skb);
103 else if (dst->neighbour)
104 return dst->neighbour->output(skb);
105
106 IP6_INC_STATS_BH(dev_net(dst->dev),
107 ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);
108 kfree_skb(skb);
109 return -EINVAL;
110
111 }
112
113 /* dev_loopback_xmit for use with netfilter. */
114 static int ip6_dev_loopback_xmit(struct sk_buff *newskb)
115 {
116 skb_reset_mac_header(newskb);
117 __skb_pull(newskb, skb_network_offset(newskb));
118 newskb->pkt_type = PACKET_LOOPBACK;
119 newskb->ip_summed = CHECKSUM_UNNECESSARY;
120 WARN_ON(!newskb->dst);
121
122 netif_rx(newskb);
123 return 0;
124 }
125
126
127 static int ip6_output2(struct sk_buff *skb)
128 {
129 struct dst_entry *dst = skb->dst;
130 struct net_device *dev = dst->dev;
131
132 skb->protocol = htons(ETH_P_IPV6);
133 skb->dev = dev;
134
135 if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
136 struct ipv6_pinfo* np = skb->sk ? inet6_sk(skb->sk) : NULL;
137 struct inet6_dev *idev = ip6_dst_idev(skb->dst);
138
139 if (!(dev->flags & IFF_LOOPBACK) && (!np || np->mc_loop) &&
140 ((mroute6_socket && !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) ||
141 ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr,
142 &ipv6_hdr(skb)->saddr))) {
143 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
144
145 /* Do not check for IFF_ALLMULTI; multicast routing
146 is not supported in any case.
147 */
148 if (newskb)
149 NF_HOOK(PF_INET6, NF_INET_POST_ROUTING, newskb,
150 NULL, newskb->dev,
151 ip6_dev_loopback_xmit);
152
153 if (ipv6_hdr(skb)->hop_limit == 0) {
154 IP6_INC_STATS(dev_net(dev), idev,
155 IPSTATS_MIB_OUTDISCARDS);
156 kfree_skb(skb);
157 return 0;
158 }
159 }
160
161 IP6_INC_STATS(dev_net(dev), idev, IPSTATS_MIB_OUTMCASTPKTS);
162 }
163
164 return NF_HOOK(PF_INET6, NF_INET_POST_ROUTING, skb, NULL, skb->dev,
165 ip6_output_finish);
166 }
167
168 static inline int ip6_skb_dst_mtu(struct sk_buff *skb)
169 {
170 struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL;
171
172 return (np && np->pmtudisc == IPV6_PMTUDISC_PROBE) ?
173 skb->dst->dev->mtu : dst_mtu(skb->dst);
174 }
175
176 int ip6_output(struct sk_buff *skb)
177 {
178 struct inet6_dev *idev = ip6_dst_idev(skb->dst);
179 if (unlikely(idev->cnf.disable_ipv6)) {
180 IP6_INC_STATS(dev_net(skb->dst->dev), idev,
181 IPSTATS_MIB_OUTDISCARDS);
182 kfree_skb(skb);
183 return 0;
184 }
185
186 if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
187 dst_allfrag(skb->dst))
188 return ip6_fragment(skb, ip6_output2);
189 else
190 return ip6_output2(skb);
191 }
192
193 /*
194 * xmit an sk_buff (used by TCP)
195 */
196
197 int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
198 struct ipv6_txoptions *opt, int ipfragok)
199 {
200 struct net *net = sock_net(sk);
201 struct ipv6_pinfo *np = inet6_sk(sk);
202 struct in6_addr *first_hop = &fl->fl6_dst;
203 struct dst_entry *dst = skb->dst;
204 struct ipv6hdr *hdr;
205 u8 proto = fl->proto;
206 int seg_len = skb->len;
207 int hlimit, tclass;
208 u32 mtu;
209
210 if (opt) {
211 unsigned int head_room;
212
213 /* First: exthdrs may take lots of space (~8K for now)
214 MAX_HEADER is not enough.
215 */
216 head_room = opt->opt_nflen + opt->opt_flen;
217 seg_len += head_room;
218 head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);
219
220 if (skb_headroom(skb) < head_room) {
221 struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
222 if (skb2 == NULL) {
223 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
224 IPSTATS_MIB_OUTDISCARDS);
225 kfree_skb(skb);
226 return -ENOBUFS;
227 }
228 kfree_skb(skb);
229 skb = skb2;
230 if (sk)
231 skb_set_owner_w(skb, sk);
232 }
233 if (opt->opt_flen)
234 ipv6_push_frag_opts(skb, opt, &proto);
235 if (opt->opt_nflen)
236 ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop);
237 }
238
239 skb_push(skb, sizeof(struct ipv6hdr));
240 skb_reset_network_header(skb);
241 hdr = ipv6_hdr(skb);
242
243 /* Allow local fragmentation. */
244 if (ipfragok)
245 skb->local_df = 1;
246
247 /*
248 * Fill in the IPv6 header
249 */
250
251 hlimit = -1;
252 if (np)
253 hlimit = np->hop_limit;
254 if (hlimit < 0)
255 hlimit = ip6_dst_hoplimit(dst);
256
257 tclass = -1;
258 if (np)
259 tclass = np->tclass;
260 if (tclass < 0)
261 tclass = 0;
262
263 *(__be32 *)hdr = htonl(0x60000000 | (tclass << 20)) | fl->fl6_flowlabel;
264
265 hdr->payload_len = htons(seg_len);
266 hdr->nexthdr = proto;
267 hdr->hop_limit = hlimit;
268
269 ipv6_addr_copy(&hdr->saddr, &fl->fl6_src);
270 ipv6_addr_copy(&hdr->daddr, first_hop);
271
272 skb->priority = sk->sk_priority;
273 skb->mark = sk->sk_mark;
274
275 mtu = dst_mtu(dst);
276 if ((skb->len <= mtu) || skb->local_df || skb_is_gso(skb)) {
277 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
278 IPSTATS_MIB_OUTREQUESTS);
279 return NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
280 dst_output);
281 }
282
283 if (net_ratelimit())
284 printk(KERN_DEBUG "IPv6: sending pkt_too_big to self\n");
285 skb->dev = dst->dev;
286 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, skb->dev);
287 IP6_INC_STATS(net, ip6_dst_idev(skb->dst), IPSTATS_MIB_FRAGFAILS);
288 kfree_skb(skb);
289 return -EMSGSIZE;
290 }
291
292 EXPORT_SYMBOL(ip6_xmit);
293
294 /*
295 * To avoid extra problems ND packets are send through this
296 * routine. It's code duplication but I really want to avoid
297 * extra checks since ipv6_build_header is used by TCP (which
298 * is for us performance critical)
299 */
300
301 int ip6_nd_hdr(struct sock *sk, struct sk_buff *skb, struct net_device *dev,
302 const struct in6_addr *saddr, const struct in6_addr *daddr,
303 int proto, int len)
304 {
305 struct ipv6_pinfo *np = inet6_sk(sk);
306 struct ipv6hdr *hdr;
307 int totlen;
308
309 skb->protocol = htons(ETH_P_IPV6);
310 skb->dev = dev;
311
312 totlen = len + sizeof(struct ipv6hdr);
313
314 skb_reset_network_header(skb);
315 skb_put(skb, sizeof(struct ipv6hdr));
316 hdr = ipv6_hdr(skb);
317
318 *(__be32*)hdr = htonl(0x60000000);
319
320 hdr->payload_len = htons(len);
321 hdr->nexthdr = proto;
322 hdr->hop_limit = np->hop_limit;
323
324 ipv6_addr_copy(&hdr->saddr, saddr);
325 ipv6_addr_copy(&hdr->daddr, daddr);
326
327 return 0;
328 }
329
330 static int ip6_call_ra_chain(struct sk_buff *skb, int sel)
331 {
332 struct ip6_ra_chain *ra;
333 struct sock *last = NULL;
334
335 read_lock(&ip6_ra_lock);
336 for (ra = ip6_ra_chain; ra; ra = ra->next) {
337 struct sock *sk = ra->sk;
338 if (sk && ra->sel == sel &&
339 (!sk->sk_bound_dev_if ||
340 sk->sk_bound_dev_if == skb->dev->ifindex)) {
341 if (last) {
342 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
343 if (skb2)
344 rawv6_rcv(last, skb2);
345 }
346 last = sk;
347 }
348 }
349
350 if (last) {
351 rawv6_rcv(last, skb);
352 read_unlock(&ip6_ra_lock);
353 return 1;
354 }
355 read_unlock(&ip6_ra_lock);
356 return 0;
357 }
358
359 static int ip6_forward_proxy_check(struct sk_buff *skb)
360 {
361 struct ipv6hdr *hdr = ipv6_hdr(skb);
362 u8 nexthdr = hdr->nexthdr;
363 int offset;
364
365 if (ipv6_ext_hdr(nexthdr)) {
366 offset = ipv6_skip_exthdr(skb, sizeof(*hdr), &nexthdr);
367 if (offset < 0)
368 return 0;
369 } else
370 offset = sizeof(struct ipv6hdr);
371
372 if (nexthdr == IPPROTO_ICMPV6) {
373 struct icmp6hdr *icmp6;
374
375 if (!pskb_may_pull(skb, (skb_network_header(skb) +
376 offset + 1 - skb->data)))
377 return 0;
378
379 icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset);
380
381 switch (icmp6->icmp6_type) {
382 case NDISC_ROUTER_SOLICITATION:
383 case NDISC_ROUTER_ADVERTISEMENT:
384 case NDISC_NEIGHBOUR_SOLICITATION:
385 case NDISC_NEIGHBOUR_ADVERTISEMENT:
386 case NDISC_REDIRECT:
387 /* For reaction involving unicast neighbor discovery
388 * message destined to the proxied address, pass it to
389 * input function.
390 */
391 return 1;
392 default:
393 break;
394 }
395 }
396
397 /*
398 * The proxying router can't forward traffic sent to a link-local
399 * address, so signal the sender and discard the packet. This
400 * behavior is clarified by the MIPv6 specification.
401 */
402 if (ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) {
403 dst_link_failure(skb);
404 return -1;
405 }
406
407 return 0;
408 }
409
410 static inline int ip6_forward_finish(struct sk_buff *skb)
411 {
412 return dst_output(skb);
413 }
414
415 int ip6_forward(struct sk_buff *skb)
416 {
417 struct dst_entry *dst = skb->dst;
418 struct ipv6hdr *hdr = ipv6_hdr(skb);
419 struct inet6_skb_parm *opt = IP6CB(skb);
420 struct net *net = dev_net(dst->dev);
421
422 if (net->ipv6.devconf_all->forwarding == 0)
423 goto error;
424
425 if (skb_warn_if_lro(skb))
426 goto drop;
427
428 if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) {
429 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS);
430 goto drop;
431 }
432
433 skb_forward_csum(skb);
434
435 /*
436 * We DO NOT make any processing on
437 * RA packets, pushing them to user level AS IS
438 * without ane WARRANTY that application will be able
439 * to interpret them. The reason is that we
440 * cannot make anything clever here.
441 *
442 * We are not end-node, so that if packet contains
443 * AH/ESP, we cannot make anything.
444 * Defragmentation also would be mistake, RA packets
445 * cannot be fragmented, because there is no warranty
446 * that different fragments will go along one path. --ANK
447 */
448 if (opt->ra) {
449 u8 *ptr = skb_network_header(skb) + opt->ra;
450 if (ip6_call_ra_chain(skb, (ptr[2]<<8) + ptr[3]))
451 return 0;
452 }
453
454 /*
455 * check and decrement ttl
456 */
457 if (hdr->hop_limit <= 1) {
458 /* Force OUTPUT device used as source address */
459 skb->dev = dst->dev;
460 icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
461 0, skb->dev);
462 IP6_INC_STATS_BH(net,
463 ip6_dst_idev(dst), IPSTATS_MIB_INHDRERRORS);
464
465 kfree_skb(skb);
466 return -ETIMEDOUT;
467 }
468
469 /* XXX: idev->cnf.proxy_ndp? */
470 if (net->ipv6.devconf_all->proxy_ndp &&
471 pneigh_lookup(&nd_tbl, net, &hdr->daddr, skb->dev, 0)) {
472 int proxied = ip6_forward_proxy_check(skb);
473 if (proxied > 0)
474 return ip6_input(skb);
475 else if (proxied < 0) {
476 IP6_INC_STATS(net, ip6_dst_idev(dst),
477 IPSTATS_MIB_INDISCARDS);
478 goto drop;
479 }
480 }
481
482 if (!xfrm6_route_forward(skb)) {
483 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS);
484 goto drop;
485 }
486 dst = skb->dst;
487
488 /* IPv6 specs say nothing about it, but it is clear that we cannot
489 send redirects to source routed frames.
490 We don't send redirects to frames decapsulated from IPsec.
491 */
492 if (skb->dev == dst->dev && dst->neighbour && opt->srcrt == 0 &&
493 !skb->sp) {
494 struct in6_addr *target = NULL;
495 struct rt6_info *rt;
496 struct neighbour *n = dst->neighbour;
497
498 /*
499 * incoming and outgoing devices are the same
500 * send a redirect.
501 */
502
503 rt = (struct rt6_info *) dst;
504 if ((rt->rt6i_flags & RTF_GATEWAY))
505 target = (struct in6_addr*)&n->primary_key;
506 else
507 target = &hdr->daddr;
508
509 /* Limit redirects both by destination (here)
510 and by source (inside ndisc_send_redirect)
511 */
512 if (xrlim_allow(dst, 1*HZ))
513 ndisc_send_redirect(skb, n, target);
514 } else {
515 int addrtype = ipv6_addr_type(&hdr->saddr);
516
517 /* This check is security critical. */
518 if (addrtype == IPV6_ADDR_ANY ||
519 addrtype & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LOOPBACK))
520 goto error;
521 if (addrtype & IPV6_ADDR_LINKLOCAL) {
522 icmpv6_send(skb, ICMPV6_DEST_UNREACH,
523 ICMPV6_NOT_NEIGHBOUR, 0, skb->dev);
524 goto error;
525 }
526 }
527
528 if (skb->len > dst_mtu(dst)) {
529 /* Again, force OUTPUT device used as source address */
530 skb->dev = dst->dev;
531 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, dst_mtu(dst), skb->dev);
532 IP6_INC_STATS_BH(net,
533 ip6_dst_idev(dst), IPSTATS_MIB_INTOOBIGERRORS);
534 IP6_INC_STATS_BH(net,
535 ip6_dst_idev(dst), IPSTATS_MIB_FRAGFAILS);
536 kfree_skb(skb);
537 return -EMSGSIZE;
538 }
539
540 if (skb_cow(skb, dst->dev->hard_header_len)) {
541 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTDISCARDS);
542 goto drop;
543 }
544
545 hdr = ipv6_hdr(skb);
546
547 /* Mangling hops number delayed to point after skb COW */
548
549 hdr->hop_limit--;
550
551 IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);
552 return NF_HOOK(PF_INET6, NF_INET_FORWARD, skb, skb->dev, dst->dev,
553 ip6_forward_finish);
554
555 error:
556 IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_INADDRERRORS);
557 drop:
558 kfree_skb(skb);
559 return -EINVAL;
560 }
561
562 static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
563 {
564 to->pkt_type = from->pkt_type;
565 to->priority = from->priority;
566 to->protocol = from->protocol;
567 dst_release(to->dst);
568 to->dst = dst_clone(from->dst);
569 to->dev = from->dev;
570 to->mark = from->mark;
571
572 #ifdef CONFIG_NET_SCHED
573 to->tc_index = from->tc_index;
574 #endif
575 nf_copy(to, from);
576 #if defined(CONFIG_NETFILTER_XT_TARGET_TRACE) || \
577 defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE)
578 to->nf_trace = from->nf_trace;
579 #endif
580 skb_copy_secmark(to, from);
581 }
582
583 int ip6_find_1stfragopt(struct sk_buff *skb, u8 **nexthdr)
584 {
585 u16 offset = sizeof(struct ipv6hdr);
586 struct ipv6_opt_hdr *exthdr =
587 (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1);
588 unsigned int packet_len = skb->tail - skb->network_header;
589 int found_rhdr = 0;
590 *nexthdr = &ipv6_hdr(skb)->nexthdr;
591
592 while (offset + 1 <= packet_len) {
593
594 switch (**nexthdr) {
595
596 case NEXTHDR_HOP:
597 break;
598 case NEXTHDR_ROUTING:
599 found_rhdr = 1;
600 break;
601 case NEXTHDR_DEST:
602 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
603 if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0)
604 break;
605 #endif
606 if (found_rhdr)
607 return offset;
608 break;
609 default :
610 return offset;
611 }
612
613 offset += ipv6_optlen(exthdr);
614 *nexthdr = &exthdr->nexthdr;
615 exthdr = (struct ipv6_opt_hdr *)(skb_network_header(skb) +
616 offset);
617 }
618
619 return offset;
620 }
621
622 static int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
623 {
624 struct sk_buff *frag;
625 struct rt6_info *rt = (struct rt6_info*)skb->dst;
626 struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL;
627 struct ipv6hdr *tmp_hdr;
628 struct frag_hdr *fh;
629 unsigned int mtu, hlen, left, len;
630 __be32 frag_id = 0;
631 int ptr, offset = 0, err=0;
632 u8 *prevhdr, nexthdr = 0;
633 struct net *net = dev_net(skb->dst->dev);
634
635 hlen = ip6_find_1stfragopt(skb, &prevhdr);
636 nexthdr = *prevhdr;
637
638 mtu = ip6_skb_dst_mtu(skb);
639
640 /* We must not fragment if the socket is set to force MTU discovery
641 * or if the skb it not generated by a local socket. (This last
642 * check should be redundant, but it's free.)
643 */
644 if (!skb->local_df) {
645 skb->dev = skb->dst->dev;
646 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, skb->dev);
647 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
648 IPSTATS_MIB_FRAGFAILS);
649 kfree_skb(skb);
650 return -EMSGSIZE;
651 }
652
653 if (np && np->frag_size < mtu) {
654 if (np->frag_size)
655 mtu = np->frag_size;
656 }
657 mtu -= hlen + sizeof(struct frag_hdr);
658
659 if (skb_shinfo(skb)->frag_list) {
660 int first_len = skb_pagelen(skb);
661 int truesizes = 0;
662
663 if (first_len - hlen > mtu ||
664 ((first_len - hlen) & 7) ||
665 skb_cloned(skb))
666 goto slow_path;
667
668 for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
669 /* Correct geometry. */
670 if (frag->len > mtu ||
671 ((frag->len & 7) && frag->next) ||
672 skb_headroom(frag) < hlen)
673 goto slow_path;
674
675 /* Partially cloned skb? */
676 if (skb_shared(frag))
677 goto slow_path;
678
679 BUG_ON(frag->sk);
680 if (skb->sk) {
681 sock_hold(skb->sk);
682 frag->sk = skb->sk;
683 frag->destructor = sock_wfree;
684 truesizes += frag->truesize;
685 }
686 }
687
688 err = 0;
689 offset = 0;
690 frag = skb_shinfo(skb)->frag_list;
691 skb_shinfo(skb)->frag_list = NULL;
692 /* BUILD HEADER */
693
694 *prevhdr = NEXTHDR_FRAGMENT;
695 tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);
696 if (!tmp_hdr) {
697 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
698 IPSTATS_MIB_FRAGFAILS);
699 return -ENOMEM;
700 }
701
702 __skb_pull(skb, hlen);
703 fh = (struct frag_hdr*)__skb_push(skb, sizeof(struct frag_hdr));
704 __skb_push(skb, hlen);
705 skb_reset_network_header(skb);
706 memcpy(skb_network_header(skb), tmp_hdr, hlen);
707
708 ipv6_select_ident(skb, fh);
709 fh->nexthdr = nexthdr;
710 fh->reserved = 0;
711 fh->frag_off = htons(IP6_MF);
712 frag_id = fh->identification;
713
714 first_len = skb_pagelen(skb);
715 skb->data_len = first_len - skb_headlen(skb);
716 skb->truesize -= truesizes;
717 skb->len = first_len;
718 ipv6_hdr(skb)->payload_len = htons(first_len -
719 sizeof(struct ipv6hdr));
720
721 dst_hold(&rt->u.dst);
722
723 for (;;) {
724 /* Prepare header of the next frame,
725 * before previous one went down. */
726 if (frag) {
727 frag->ip_summed = CHECKSUM_NONE;
728 skb_reset_transport_header(frag);
729 fh = (struct frag_hdr*)__skb_push(frag, sizeof(struct frag_hdr));
730 __skb_push(frag, hlen);
731 skb_reset_network_header(frag);
732 memcpy(skb_network_header(frag), tmp_hdr,
733 hlen);
734 offset += skb->len - hlen - sizeof(struct frag_hdr);
735 fh->nexthdr = nexthdr;
736 fh->reserved = 0;
737 fh->frag_off = htons(offset);
738 if (frag->next != NULL)
739 fh->frag_off |= htons(IP6_MF);
740 fh->identification = frag_id;
741 ipv6_hdr(frag)->payload_len =
742 htons(frag->len -
743 sizeof(struct ipv6hdr));
744 ip6_copy_metadata(frag, skb);
745 }
746
747 err = output(skb);
748 if(!err)
749 IP6_INC_STATS(net, ip6_dst_idev(&rt->u.dst),
750 IPSTATS_MIB_FRAGCREATES);
751
752 if (err || !frag)
753 break;
754
755 skb = frag;
756 frag = skb->next;
757 skb->next = NULL;
758 }
759
760 kfree(tmp_hdr);
761
762 if (err == 0) {
763 IP6_INC_STATS(net, ip6_dst_idev(&rt->u.dst),
764 IPSTATS_MIB_FRAGOKS);
765 dst_release(&rt->u.dst);
766 return 0;
767 }
768
769 while (frag) {
770 skb = frag->next;
771 kfree_skb(frag);
772 frag = skb;
773 }
774
775 IP6_INC_STATS(net, ip6_dst_idev(&rt->u.dst),
776 IPSTATS_MIB_FRAGFAILS);
777 dst_release(&rt->u.dst);
778 return err;
779 }
780
781 slow_path:
782 left = skb->len - hlen; /* Space per frame */
783 ptr = hlen; /* Where to start from */
784
785 /*
786 * Fragment the datagram.
787 */
788
789 *prevhdr = NEXTHDR_FRAGMENT;
790
791 /*
792 * Keep copying data until we run out.
793 */
794 while(left > 0) {
795 len = left;
796 /* IF: it doesn't fit, use 'mtu' - the data space left */
797 if (len > mtu)
798 len = mtu;
799 /* IF: we are not sending upto and including the packet end
800 then align the next start on an eight byte boundary */
801 if (len < left) {
802 len &= ~7;
803 }
804 /*
805 * Allocate buffer.
806 */
807
808 if ((frag = alloc_skb(len+hlen+sizeof(struct frag_hdr)+LL_ALLOCATED_SPACE(rt->u.dst.dev), GFP_ATOMIC)) == NULL) {
809 NETDEBUG(KERN_INFO "IPv6: frag: no memory for new fragment!\n");
810 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
811 IPSTATS_MIB_FRAGFAILS);
812 err = -ENOMEM;
813 goto fail;
814 }
815
816 /*
817 * Set up data on packet
818 */
819
820 ip6_copy_metadata(frag, skb);
821 skb_reserve(frag, LL_RESERVED_SPACE(rt->u.dst.dev));
822 skb_put(frag, len + hlen + sizeof(struct frag_hdr));
823 skb_reset_network_header(frag);
824 fh = (struct frag_hdr *)(skb_network_header(frag) + hlen);
825 frag->transport_header = (frag->network_header + hlen +
826 sizeof(struct frag_hdr));
827
828 /*
829 * Charge the memory for the fragment to any owner
830 * it might possess
831 */
832 if (skb->sk)
833 skb_set_owner_w(frag, skb->sk);
834
835 /*
836 * Copy the packet header into the new buffer.
837 */
838 skb_copy_from_linear_data(skb, skb_network_header(frag), hlen);
839
840 /*
841 * Build fragment header.
842 */
843 fh->nexthdr = nexthdr;
844 fh->reserved = 0;
845 if (!frag_id) {
846 ipv6_select_ident(skb, fh);
847 frag_id = fh->identification;
848 } else
849 fh->identification = frag_id;
850
851 /*
852 * Copy a block of the IP datagram.
853 */
854 if (skb_copy_bits(skb, ptr, skb_transport_header(frag), len))
855 BUG();
856 left -= len;
857
858 fh->frag_off = htons(offset);
859 if (left > 0)
860 fh->frag_off |= htons(IP6_MF);
861 ipv6_hdr(frag)->payload_len = htons(frag->len -
862 sizeof(struct ipv6hdr));
863
864 ptr += len;
865 offset += len;
866
867 /*
868 * Put this fragment into the sending queue.
869 */
870 err = output(frag);
871 if (err)
872 goto fail;
873
874 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
875 IPSTATS_MIB_FRAGCREATES);
876 }
877 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
878 IPSTATS_MIB_FRAGOKS);
879 kfree_skb(skb);
880 return err;
881
882 fail:
883 IP6_INC_STATS(net, ip6_dst_idev(skb->dst),
884 IPSTATS_MIB_FRAGFAILS);
885 kfree_skb(skb);
886 return err;
887 }
888
889 static inline int ip6_rt_check(struct rt6key *rt_key,
890 struct in6_addr *fl_addr,
891 struct in6_addr *addr_cache)
892 {
893 return ((rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) &&
894 (addr_cache == NULL || !ipv6_addr_equal(fl_addr, addr_cache)));
895 }
896
897 static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
898 struct dst_entry *dst,
899 struct flowi *fl)
900 {
901 struct ipv6_pinfo *np = inet6_sk(sk);
902 struct rt6_info *rt = (struct rt6_info *)dst;
903
904 if (!dst)
905 goto out;
906
907 /* Yes, checking route validity in not connected
908 * case is not very simple. Take into account,
909 * that we do not support routing by source, TOS,
910 * and MSG_DONTROUTE --ANK (980726)
911 *
912 * 1. ip6_rt_check(): If route was host route,
913 * check that cached destination is current.
914 * If it is network route, we still may
915 * check its validity using saved pointer
916 * to the last used address: daddr_cache.
917 * We do not want to save whole address now,
918 * (because main consumer of this service
919 * is tcp, which has not this problem),
920 * so that the last trick works only on connected
921 * sockets.
922 * 2. oif also should be the same.
923 */
924 if (ip6_rt_check(&rt->rt6i_dst, &fl->fl6_dst, np->daddr_cache) ||
925 #ifdef CONFIG_IPV6_SUBTREES
926 ip6_rt_check(&rt->rt6i_src, &fl->fl6_src, np->saddr_cache) ||
927 #endif
928 (fl->oif && fl->oif != dst->dev->ifindex)) {
929 dst_release(dst);
930 dst = NULL;
931 }
932
933 out:
934 return dst;
935 }
936
937 static int ip6_dst_lookup_tail(struct sock *sk,
938 struct dst_entry **dst, struct flowi *fl)
939 {
940 int err;
941 struct net *net = sock_net(sk);
942
943 if (*dst == NULL)
944 *dst = ip6_route_output(net, sk, fl);
945
946 if ((err = (*dst)->error))
947 goto out_err_release;
948
949 if (ipv6_addr_any(&fl->fl6_src)) {
950 err = ipv6_dev_get_saddr(net, ip6_dst_idev(*dst)->dev,
951 &fl->fl6_dst,
952 sk ? inet6_sk(sk)->srcprefs : 0,
953 &fl->fl6_src);
954 if (err)
955 goto out_err_release;
956 }
957
958 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
959 /*
960 * Here if the dst entry we've looked up
961 * has a neighbour entry that is in the INCOMPLETE
962 * state and the src address from the flow is
963 * marked as OPTIMISTIC, we release the found
964 * dst entry and replace it instead with the
965 * dst entry of the nexthop router
966 */
967 if ((*dst)->neighbour && !((*dst)->neighbour->nud_state & NUD_VALID)) {
968 struct inet6_ifaddr *ifp;
969 struct flowi fl_gw;
970 int redirect;
971
972 ifp = ipv6_get_ifaddr(net, &fl->fl6_src,
973 (*dst)->dev, 1);
974
975 redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);
976 if (ifp)
977 in6_ifa_put(ifp);
978
979 if (redirect) {
980 /*
981 * We need to get the dst entry for the
982 * default router instead
983 */
984 dst_release(*dst);
985 memcpy(&fl_gw, fl, sizeof(struct flowi));
986 memset(&fl_gw.fl6_dst, 0, sizeof(struct in6_addr));
987 *dst = ip6_route_output(net, sk, &fl_gw);
988 if ((err = (*dst)->error))
989 goto out_err_release;
990 }
991 }
992 #endif
993
994 return 0;
995
996 out_err_release:
997 if (err == -ENETUNREACH)
998 IP6_INC_STATS_BH(net, NULL, IPSTATS_MIB_OUTNOROUTES);
999 dst_release(*dst);
1000 *dst = NULL;
1001 return err;
1002 }
1003
1004 /**
1005 * ip6_dst_lookup - perform route lookup on flow
1006 * @sk: socket which provides route info
1007 * @dst: pointer to dst_entry * for result
1008 * @fl: flow to lookup
1009 *
1010 * This function performs a route lookup on the given flow.
1011 *
1012 * It returns zero on success, or a standard errno code on error.
1013 */
1014 int ip6_dst_lookup(struct sock *sk, struct dst_entry **dst, struct flowi *fl)
1015 {
1016 *dst = NULL;
1017 return ip6_dst_lookup_tail(sk, dst, fl);
1018 }
1019 EXPORT_SYMBOL_GPL(ip6_dst_lookup);
1020
1021 /**
1022 * ip6_sk_dst_lookup - perform socket cached route lookup on flow
1023 * @sk: socket which provides the dst cache and route info
1024 * @dst: pointer to dst_entry * for result
1025 * @fl: flow to lookup
1026 *
1027 * This function performs a route lookup on the given flow with the
1028 * possibility of using the cached route in the socket if it is valid.
1029 * It will take the socket dst lock when operating on the dst cache.
1030 * As a result, this function can only be used in process context.
1031 *
1032 * It returns zero on success, or a standard errno code on error.
1033 */
1034 int ip6_sk_dst_lookup(struct sock *sk, struct dst_entry **dst, struct flowi *fl)
1035 {
1036 *dst = NULL;
1037 if (sk) {
1038 *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);
1039 *dst = ip6_sk_dst_check(sk, *dst, fl);
1040 }
1041
1042 return ip6_dst_lookup_tail(sk, dst, fl);
1043 }
1044 EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup);
1045
1046 static inline int ip6_ufo_append_data(struct sock *sk,
1047 int getfrag(void *from, char *to, int offset, int len,
1048 int odd, struct sk_buff *skb),
1049 void *from, int length, int hh_len, int fragheaderlen,
1050 int transhdrlen, int mtu,unsigned int flags)
1051
1052 {
1053 struct sk_buff *skb;
1054 int err;
1055
1056 /* There is support for UDP large send offload by network
1057 * device, so create one single skb packet containing complete
1058 * udp datagram
1059 */
1060 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) {
1061 skb = sock_alloc_send_skb(sk,
1062 hh_len + fragheaderlen + transhdrlen + 20,
1063 (flags & MSG_DONTWAIT), &err);
1064 if (skb == NULL)
1065 return -ENOMEM;
1066
1067 /* reserve space for Hardware header */
1068 skb_reserve(skb, hh_len);
1069
1070 /* create space for UDP/IP header */
1071 skb_put(skb,fragheaderlen + transhdrlen);
1072
1073 /* initialize network header pointer */
1074 skb_reset_network_header(skb);
1075
1076 /* initialize protocol header pointer */
1077 skb->transport_header = skb->network_header + fragheaderlen;
1078
1079 skb->ip_summed = CHECKSUM_PARTIAL;
1080 skb->csum = 0;
1081 sk->sk_sndmsg_off = 0;
1082 }
1083
1084 err = skb_append_datato_frags(sk,skb, getfrag, from,
1085 (length - transhdrlen));
1086 if (!err) {
1087 struct frag_hdr fhdr;
1088
1089 /* specify the length of each IP datagram fragment*/
1090 skb_shinfo(skb)->gso_size = mtu - fragheaderlen -
1091 sizeof(struct frag_hdr);
1092 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
1093 ipv6_select_ident(skb, &fhdr);
1094 skb_shinfo(skb)->ip6_frag_id = fhdr.identification;
1095 __skb_queue_tail(&sk->sk_write_queue, skb);
1096
1097 return 0;
1098 }
1099 /* There is not enough support do UPD LSO,
1100 * so follow normal path
1101 */
1102 kfree_skb(skb);
1103
1104 return err;
1105 }
1106
1107 int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to,
1108 int offset, int len, int odd, struct sk_buff *skb),
1109 void *from, int length, int transhdrlen,
1110 int hlimit, int tclass, struct ipv6_txoptions *opt, struct flowi *fl,
1111 struct rt6_info *rt, unsigned int flags)
1112 {
1113 struct inet_sock *inet = inet_sk(sk);
1114 struct ipv6_pinfo *np = inet6_sk(sk);
1115 struct sk_buff *skb;
1116 unsigned int maxfraglen, fragheaderlen;
1117 int exthdrlen;
1118 int hh_len;
1119 int mtu;
1120 int copy;
1121 int err;
1122 int offset = 0;
1123 int csummode = CHECKSUM_NONE;
1124
1125 if (flags&MSG_PROBE)
1126 return 0;
1127 if (skb_queue_empty(&sk->sk_write_queue)) {
1128 /*
1129 * setup for corking
1130 */
1131 if (opt) {
1132 if (np->cork.opt == NULL) {
1133 np->cork.opt = kmalloc(opt->tot_len,
1134 sk->sk_allocation);
1135 if (unlikely(np->cork.opt == NULL))
1136 return -ENOBUFS;
1137 } else if (np->cork.opt->tot_len < opt->tot_len) {
1138 printk(KERN_DEBUG "ip6_append_data: invalid option length\n");
1139 return -EINVAL;
1140 }
1141 memcpy(np->cork.opt, opt, opt->tot_len);
1142 inet->cork.flags |= IPCORK_OPT;
1143 /* need source address above miyazawa*/
1144 }
1145 dst_hold(&rt->u.dst);
1146 inet->cork.dst = &rt->u.dst;
1147 inet->cork.fl = *fl;
1148 np->cork.hop_limit = hlimit;
1149 np->cork.tclass = tclass;
1150 mtu = np->pmtudisc == IPV6_PMTUDISC_PROBE ?
1151 rt->u.dst.dev->mtu : dst_mtu(rt->u.dst.path);
1152 if (np->frag_size < mtu) {
1153 if (np->frag_size)
1154 mtu = np->frag_size;
1155 }
1156 inet->cork.fragsize = mtu;
1157 if (dst_allfrag(rt->u.dst.path))
1158 inet->cork.flags |= IPCORK_ALLFRAG;
1159 inet->cork.length = 0;
1160 sk->sk_sndmsg_page = NULL;
1161 sk->sk_sndmsg_off = 0;
1162 exthdrlen = rt->u.dst.header_len + (opt ? opt->opt_flen : 0) -
1163 rt->rt6i_nfheader_len;
1164 length += exthdrlen;
1165 transhdrlen += exthdrlen;
1166 } else {
1167 rt = (struct rt6_info *)inet->cork.dst;
1168 fl = &inet->cork.fl;
1169 if (inet->cork.flags & IPCORK_OPT)
1170 opt = np->cork.opt;
1171 transhdrlen = 0;
1172 exthdrlen = 0;
1173 mtu = inet->cork.fragsize;
1174 }
1175
1176 hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);
1177
1178 fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len +
1179 (opt ? opt->opt_nflen : 0);
1180 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen - sizeof(struct frag_hdr);
1181
1182 if (mtu <= sizeof(struct ipv6hdr) + IPV6_MAXPLEN) {
1183 if (inet->cork.length + length > sizeof(struct ipv6hdr) + IPV6_MAXPLEN - fragheaderlen) {
1184 ipv6_local_error(sk, EMSGSIZE, fl, mtu-exthdrlen);
1185 return -EMSGSIZE;
1186 }
1187 }
1188
1189 /*
1190 * Let's try using as much space as possible.
1191 * Use MTU if total length of the message fits into the MTU.
1192 * Otherwise, we need to reserve fragment header and
1193 * fragment alignment (= 8-15 octects, in total).
1194 *
1195 * Note that we may need to "move" the data from the tail of
1196 * of the buffer to the new fragment when we split
1197 * the message.
1198 *
1199 * FIXME: It may be fragmented into multiple chunks
1200 * at once if non-fragmentable extension headers
1201 * are too large.
1202 * --yoshfuji
1203 */
1204
1205 inet->cork.length += length;
1206 if (((length > mtu) && (sk->sk_protocol == IPPROTO_UDP)) &&
1207 (rt->u.dst.dev->features & NETIF_F_UFO)) {
1208
1209 err = ip6_ufo_append_data(sk, getfrag, from, length, hh_len,
1210 fragheaderlen, transhdrlen, mtu,
1211 flags);
1212 if (err)
1213 goto error;
1214 return 0;
1215 }
1216
1217 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
1218 goto alloc_new_skb;
1219
1220 while (length > 0) {
1221 /* Check if the remaining data fits into current packet. */
1222 copy = (inet->cork.length <= mtu && !(inet->cork.flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len;
1223 if (copy < length)
1224 copy = maxfraglen - skb->len;
1225
1226 if (copy <= 0) {
1227 char *data;
1228 unsigned int datalen;
1229 unsigned int fraglen;
1230 unsigned int fraggap;
1231 unsigned int alloclen;
1232 struct sk_buff *skb_prev;
1233 alloc_new_skb:
1234 skb_prev = skb;
1235
1236 /* There's no room in the current skb */
1237 if (skb_prev)
1238 fraggap = skb_prev->len - maxfraglen;
1239 else
1240 fraggap = 0;
1241
1242 /*
1243 * If remaining data exceeds the mtu,
1244 * we know we need more fragment(s).
1245 */
1246 datalen = length + fraggap;
1247 if (datalen > (inet->cork.length <= mtu && !(inet->cork.flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen)
1248 datalen = maxfraglen - fragheaderlen;
1249
1250 fraglen = datalen + fragheaderlen;
1251 if ((flags & MSG_MORE) &&
1252 !(rt->u.dst.dev->features&NETIF_F_SG))
1253 alloclen = mtu;
1254 else
1255 alloclen = datalen + fragheaderlen;
1256
1257 /*
1258 * The last fragment gets additional space at tail.
1259 * Note: we overallocate on fragments with MSG_MODE
1260 * because we have no idea if we're the last one.
1261 */
1262 if (datalen == length + fraggap)
1263 alloclen += rt->u.dst.trailer_len;
1264
1265 /*
1266 * We just reserve space for fragment header.
1267 * Note: this may be overallocation if the message
1268 * (without MSG_MORE) fits into the MTU.
1269 */
1270 alloclen += sizeof(struct frag_hdr);
1271
1272 if (transhdrlen) {
1273 skb = sock_alloc_send_skb(sk,
1274 alloclen + hh_len,
1275 (flags & MSG_DONTWAIT), &err);
1276 } else {
1277 skb = NULL;
1278 if (atomic_read(&sk->sk_wmem_alloc) <=
1279 2 * sk->sk_sndbuf)
1280 skb = sock_wmalloc(sk,
1281 alloclen + hh_len, 1,
1282 sk->sk_allocation);
1283 if (unlikely(skb == NULL))
1284 err = -ENOBUFS;
1285 }
1286 if (skb == NULL)
1287 goto error;
1288 /*
1289 * Fill in the control structures
1290 */
1291 skb->ip_summed = csummode;
1292 skb->csum = 0;
1293 /* reserve for fragmentation */
1294 skb_reserve(skb, hh_len+sizeof(struct frag_hdr));
1295
1296 /*
1297 * Find where to start putting bytes
1298 */
1299 data = skb_put(skb, fraglen);
1300 skb_set_network_header(skb, exthdrlen);
1301 data += fragheaderlen;
1302 skb->transport_header = (skb->network_header +
1303 fragheaderlen);
1304 if (fraggap) {
1305 skb->csum = skb_copy_and_csum_bits(
1306 skb_prev, maxfraglen,
1307 data + transhdrlen, fraggap, 0);
1308 skb_prev->csum = csum_sub(skb_prev->csum,
1309 skb->csum);
1310 data += fraggap;
1311 pskb_trim_unique(skb_prev, maxfraglen);
1312 }
1313 copy = datalen - transhdrlen - fraggap;
1314 if (copy < 0) {
1315 err = -EINVAL;
1316 kfree_skb(skb);
1317 goto error;
1318 } else if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
1319 err = -EFAULT;
1320 kfree_skb(skb);
1321 goto error;
1322 }
1323
1324 offset += copy;
1325 length -= datalen - fraggap;
1326 transhdrlen = 0;
1327 exthdrlen = 0;
1328 csummode = CHECKSUM_NONE;
1329
1330 /*
1331 * Put the packet on the pending queue
1332 */
1333 __skb_queue_tail(&sk->sk_write_queue, skb);
1334 continue;
1335 }
1336
1337 if (copy > length)
1338 copy = length;
1339
1340 if (!(rt->u.dst.dev->features&NETIF_F_SG)) {
1341 unsigned int off;
1342
1343 off = skb->len;
1344 if (getfrag(from, skb_put(skb, copy),
1345 offset, copy, off, skb) < 0) {
1346 __skb_trim(skb, off);
1347 err = -EFAULT;
1348 goto error;
1349 }
1350 } else {
1351 int i = skb_shinfo(skb)->nr_frags;
1352 skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
1353 struct page *page = sk->sk_sndmsg_page;
1354 int off = sk->sk_sndmsg_off;
1355 unsigned int left;
1356
1357 if (page && (left = PAGE_SIZE - off) > 0) {
1358 if (copy >= left)
1359 copy = left;
1360 if (page != frag->page) {
1361 if (i == MAX_SKB_FRAGS) {
1362 err = -EMSGSIZE;
1363 goto error;
1364 }
1365 get_page(page);
1366 skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0);
1367 frag = &skb_shinfo(skb)->frags[i];
1368 }
1369 } else if(i < MAX_SKB_FRAGS) {
1370 if (copy > PAGE_SIZE)
1371 copy = PAGE_SIZE;
1372 page = alloc_pages(sk->sk_allocation, 0);
1373 if (page == NULL) {
1374 err = -ENOMEM;
1375 goto error;
1376 }
1377 sk->sk_sndmsg_page = page;
1378 sk->sk_sndmsg_off = 0;
1379
1380 skb_fill_page_desc(skb, i, page, 0, 0);
1381 frag = &skb_shinfo(skb)->frags[i];
1382 } else {
1383 err = -EMSGSIZE;
1384 goto error;
1385 }
1386 if (getfrag(from, page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) {
1387 err = -EFAULT;
1388 goto error;
1389 }
1390 sk->sk_sndmsg_off += copy;
1391 frag->size += copy;
1392 skb->len += copy;
1393 skb->data_len += copy;
1394 skb->truesize += copy;
1395 atomic_add(copy, &sk->sk_wmem_alloc);
1396 }
1397 offset += copy;
1398 length -= copy;
1399 }
1400 return 0;
1401 error:
1402 inet->cork.length -= length;
1403 IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
1404 return err;
1405 }
1406
1407 static void ip6_cork_release(struct inet_sock *inet, struct ipv6_pinfo *np)
1408 {
1409 inet->cork.flags &= ~IPCORK_OPT;
1410 kfree(np->cork.opt);
1411 np->cork.opt = NULL;
1412 if (inet->cork.dst) {
1413 dst_release(inet->cork.dst);
1414 inet->cork.dst = NULL;
1415 inet->cork.flags &= ~IPCORK_ALLFRAG;
1416 }
1417 memset(&inet->cork.fl, 0, sizeof(inet->cork.fl));
1418 }
1419
1420 int ip6_push_pending_frames(struct sock *sk)
1421 {
1422 struct sk_buff *skb, *tmp_skb;
1423 struct sk_buff **tail_skb;
1424 struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;
1425 struct inet_sock *inet = inet_sk(sk);
1426 struct ipv6_pinfo *np = inet6_sk(sk);
1427 struct net *net = sock_net(sk);
1428 struct ipv6hdr *hdr;
1429 struct ipv6_txoptions *opt = np->cork.opt;
1430 struct rt6_info *rt = (struct rt6_info *)inet->cork.dst;
1431 struct flowi *fl = &inet->cork.fl;
1432 unsigned char proto = fl->proto;
1433 int err = 0;
1434
1435 if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)
1436 goto out;
1437 tail_skb = &(skb_shinfo(skb)->frag_list);
1438
1439 /* move skb->data to ip header from ext header */
1440 if (skb->data < skb_network_header(skb))
1441 __skb_pull(skb, skb_network_offset(skb));
1442 while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
1443 __skb_pull(tmp_skb, skb_network_header_len(skb));
1444 *tail_skb = tmp_skb;
1445 tail_skb = &(tmp_skb->next);
1446 skb->len += tmp_skb->len;
1447 skb->data_len += tmp_skb->len;
1448 skb->truesize += tmp_skb->truesize;
1449 __sock_put(tmp_skb->sk);
1450 tmp_skb->destructor = NULL;
1451 tmp_skb->sk = NULL;
1452 }
1453
1454 /* Allow local fragmentation. */
1455 if (np->pmtudisc < IPV6_PMTUDISC_DO)
1456 skb->local_df = 1;
1457
1458 ipv6_addr_copy(final_dst, &fl->fl6_dst);
1459 __skb_pull(skb, skb_network_header_len(skb));
1460 if (opt && opt->opt_flen)
1461 ipv6_push_frag_opts(skb, opt, &proto);
1462 if (opt && opt->opt_nflen)
1463 ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst);
1464
1465 skb_push(skb, sizeof(struct ipv6hdr));
1466 skb_reset_network_header(skb);
1467 hdr = ipv6_hdr(skb);
1468
1469 *(__be32*)hdr = fl->fl6_flowlabel |
1470 htonl(0x60000000 | ((int)np->cork.tclass << 20));
1471
1472 hdr->hop_limit = np->cork.hop_limit;
1473 hdr->nexthdr = proto;
1474 ipv6_addr_copy(&hdr->saddr, &fl->fl6_src);
1475 ipv6_addr_copy(&hdr->daddr, final_dst);
1476
1477 skb->priority = sk->sk_priority;
1478 skb->mark = sk->sk_mark;
1479
1480 skb->dst = dst_clone(&rt->u.dst);
1481 IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS);
1482 if (proto == IPPROTO_ICMPV6) {
1483 struct inet6_dev *idev = ip6_dst_idev(skb->dst);
1484
1485 ICMP6MSGOUT_INC_STATS_BH(idev, icmp6_hdr(skb)->icmp6_type);
1486 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS);
1487 }
1488
1489 err = ip6_local_out(skb);
1490 if (err) {
1491 if (err > 0)
1492 err = np->recverr ? net_xmit_errno(err) : 0;
1493 if (err)
1494 goto error;
1495 }
1496
1497 out:
1498 ip6_cork_release(inet, np);
1499 return err;
1500 error:
1501 goto out;
1502 }
1503
1504 void ip6_flush_pending_frames(struct sock *sk)
1505 {
1506 struct sk_buff *skb;
1507
1508 while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) {
1509 if (skb->dst)
1510 IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb->dst),
1511 IPSTATS_MIB_OUTDISCARDS);
1512 kfree_skb(skb);
1513 }
1514
1515 ip6_cork_release(inet_sk(sk), inet6_sk(sk));
1516 }
Ubuntu Artful kernel mirror