blob: a233a7ccbc3a6d84bebf28b3c37bb79d6fa7d98b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * IPv6 output functions
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/errno.h>
Herbert Xuef76bc22008-01-11 19:15:08 -080030#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#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>
Herbert Xub59f45d2006-05-27 23:05:54 -070039#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <linux/netfilter.h>
43#include <linux/netfilter_ipv6.h>
44
45#include <net/sock.h>
46#include <net/snmp.h>
47
48#include <net/ipv6.h>
49#include <net/ndisc.h>
50#include <net/protocol.h>
51#include <net/ip6_route.h>
52#include <net/addrconf.h>
53#include <net/rawv6.h>
54#include <net/icmp.h>
55#include <net/xfrm.h>
56#include <net/checksum.h>
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +090057#include <linux/mroute6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
David Stevensad0081e2010-12-17 11:42:42 +000059int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *));
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Herbert Xuef76bc22008-01-11 19:15:08 -080061int __ip6_local_out(struct sk_buff *skb)
62{
63 int len;
64
65 len = skb->len - sizeof(struct ipv6hdr);
66 if (len > IPV6_MAXPLEN)
67 len = 0;
68 ipv6_hdr(skb)->payload_len = htons(len);
69
Jan Engelhardtb2e0b382010-03-23 04:09:07 +010070 return nf_hook(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL,
71 skb_dst(skb)->dev, dst_output);
Herbert Xuef76bc22008-01-11 19:15:08 -080072}
73
74int ip6_local_out(struct sk_buff *skb)
75{
76 int err;
77
78 err = __ip6_local_out(skb);
79 if (likely(err == 1))
80 err = dst_output(skb);
81
82 return err;
83}
84EXPORT_SYMBOL_GPL(ip6_local_out);
85
Jan Engelhardt9e508492010-04-13 15:28:11 +020086static int ip6_finish_output2(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
Eric Dumazetadf30902009-06-02 05:19:30 +000088 struct dst_entry *dst = skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 struct net_device *dev = dst->dev;
David S. Millerf6b72b62011-07-14 07:53:20 -070090 struct neighbour *neigh;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92 skb->protocol = htons(ETH_P_IPV6);
93 skb->dev = dev;
94
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -070095 if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
Eric Dumazetadf30902009-06-02 05:19:30 +000096 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Octavian Purdila7ad68482010-01-06 20:37:01 -080098 if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(skb->sk) &&
Patrick McHardyd1db2752010-05-11 14:40:55 +020099 ((mroute6_socket(dev_net(dev), skb) &&
Benjamin Therybd91b8b2008-12-10 16:07:08 -0800100 !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) ||
YOSHIFUJI Hideaki7bc570c2008-04-03 09:22:53 +0900101 ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr,
102 &ipv6_hdr(skb)->saddr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
104
105 /* Do not check for IFF_ALLMULTI; multicast routing
106 is not supported in any case.
107 */
108 if (newskb)
Jan Engelhardtb2e0b382010-03-23 04:09:07 +0100109 NF_HOOK(NFPROTO_IPV6, NF_INET_POST_ROUTING,
110 newskb, NULL, newskb->dev,
Michel Machado95603e22012-06-12 10:16:35 +0000111 dev_loopback_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700113 if (ipv6_hdr(skb)->hop_limit == 0) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700114 IP6_INC_STATS(dev_net(dev), idev,
115 IPSTATS_MIB_OUTDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 kfree_skb(skb);
117 return 0;
118 }
119 }
120
Neil Hormanedf391f2009-04-27 02:45:02 -0700121 IP6_UPD_PO_STATS(dev_net(dev), idev, IPSTATS_MIB_OUTMCAST,
122 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 }
124
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000125 rcu_read_lock();
David Miller27217452011-12-02 16:52:08 +0000126 neigh = dst_get_neighbour_noref(dst);
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000127 if (neigh) {
128 int res = neigh_output(neigh, skb);
David S. Miller05e3aa02011-07-16 17:26:00 -0700129
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000130 rcu_read_unlock();
131 return res;
132 }
133 rcu_read_unlock();
Jan Engelhardt9e508492010-04-13 15:28:11 +0200134 IP6_INC_STATS_BH(dev_net(dst->dev),
135 ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);
136 kfree_skb(skb);
137 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138}
139
Jan Engelhardt9e508492010-04-13 15:28:11 +0200140static int ip6_finish_output(struct sk_buff *skb)
141{
142 if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
143 dst_allfrag(skb_dst(skb)))
144 return ip6_fragment(skb, ip6_finish_output2);
145 else
146 return ip6_finish_output2(skb);
147}
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149int ip6_output(struct sk_buff *skb)
150{
Jan Engelhardt9e508492010-04-13 15:28:11 +0200151 struct net_device *dev = skb_dst(skb)->dev;
Eric Dumazetadf30902009-06-02 05:19:30 +0000152 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
YOSHIFUJI Hideaki778d80b2008-06-28 14:17:11 +0900153 if (unlikely(idev->cnf.disable_ipv6)) {
Jan Engelhardt9e508492010-04-13 15:28:11 +0200154 IP6_INC_STATS(dev_net(dev), idev,
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700155 IPSTATS_MIB_OUTDISCARDS);
YOSHIFUJI Hideaki778d80b2008-06-28 14:17:11 +0900156 kfree_skb(skb);
157 return 0;
158 }
159
Jan Engelhardt9c6eb282010-04-13 15:32:16 +0200160 return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING, skb, NULL, dev,
161 ip6_finish_output,
162 !(IP6CB(skb)->flags & IP6SKB_REROUTED));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165/*
Shan Weib5d43992010-04-15 16:48:48 +0000166 * xmit an sk_buff (used by TCP, SCTP and DCCP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 */
168
David S. Miller4c9483b2011-03-12 16:22:43 -0500169int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,
Eric Dumazetb903d322011-10-27 00:44:35 -0400170 struct ipv6_txoptions *opt, int tclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700172 struct net *net = sock_net(sk);
Patrick McHardyb30bd282006-03-23 01:17:25 -0800173 struct ipv6_pinfo *np = inet6_sk(sk);
David S. Miller4c9483b2011-03-12 16:22:43 -0500174 struct in6_addr *first_hop = &fl6->daddr;
Eric Dumazetadf30902009-06-02 05:19:30 +0000175 struct dst_entry *dst = skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 struct ipv6hdr *hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500177 u8 proto = fl6->flowi6_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 int seg_len = skb->len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000179 int hlimit = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 u32 mtu;
181
182 if (opt) {
Chuck Leverc2636b42007-10-23 21:07:32 -0700183 unsigned int head_room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185 /* First: exthdrs may take lots of space (~8K for now)
186 MAX_HEADER is not enough.
187 */
188 head_room = opt->opt_nflen + opt->opt_flen;
189 seg_len += head_room;
190 head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);
191
192 if (skb_headroom(skb) < head_room) {
193 struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900194 if (skb2 == NULL) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000195 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900196 IPSTATS_MIB_OUTDISCARDS);
197 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return -ENOBUFS;
199 }
Eric Dumazet808db802012-04-24 10:17:59 +0000200 consume_skb(skb);
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900201 skb = skb2;
Dan Carpenter83d7eb22010-04-30 16:42:08 -0700202 skb_set_owner_w(skb, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 }
204 if (opt->opt_flen)
205 ipv6_push_frag_opts(skb, opt, &proto);
206 if (opt->opt_nflen)
207 ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop);
208 }
209
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700210 skb_push(skb, sizeof(struct ipv6hdr));
211 skb_reset_network_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700212 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 /*
215 * Fill in the IPv6 header
216 */
Eric Dumazetb903d322011-10-27 00:44:35 -0400217 if (np)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 hlimit = np->hop_limit;
219 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400220 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
David S. Miller4c9483b2011-03-12 16:22:43 -0500222 *(__be32 *)hdr = htonl(0x60000000 | (tclass << 20)) | fl6->flowlabel;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 hdr->payload_len = htons(seg_len);
225 hdr->nexthdr = proto;
226 hdr->hop_limit = hlimit;
227
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000228 hdr->saddr = fl6->saddr;
229 hdr->daddr = *first_hop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Patrick McHardya2c20642006-01-08 22:37:26 -0800231 skb->priority = sk->sk_priority;
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800232 skb->mark = sk->sk_mark;
Patrick McHardya2c20642006-01-08 22:37:26 -0800233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 mtu = dst_mtu(dst);
Wei Yongjun283d07ac2008-08-03 21:15:59 -0700235 if ((skb->len <= mtu) || skb->local_df || skb_is_gso(skb)) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000236 IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),
Neil Hormanedf391f2009-04-27 02:45:02 -0700237 IPSTATS_MIB_OUT, skb->len);
Jan Engelhardtb2e0b382010-03-23 04:09:07 +0100238 return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL,
239 dst->dev, dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 }
241
Joe Perchese87cc472012-05-13 21:56:26 +0000242 net_dbg_ratelimited("IPv6: sending pkt_too_big to self\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 skb->dev = dst->dev;
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000244 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Eric Dumazetadf30902009-06-02 05:19:30 +0000245 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 kfree_skb(skb);
247 return -EMSGSIZE;
248}
249
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900250EXPORT_SYMBOL(ip6_xmit);
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252/*
253 * To avoid extra problems ND packets are send through this
254 * routine. It's code duplication but I really want to avoid
255 * extra checks since ipv6_build_header is used by TCP (which
256 * is for us performance critical)
257 */
258
259int ip6_nd_hdr(struct sock *sk, struct sk_buff *skb, struct net_device *dev,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900260 const struct in6_addr *saddr, const struct in6_addr *daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 int proto, int len)
262{
263 struct ipv6_pinfo *np = inet6_sk(sk);
264 struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 skb->protocol = htons(ETH_P_IPV6);
267 skb->dev = dev;
268
Arnaldo Carvalho de Melo55f79cc2007-03-14 21:05:03 -0300269 skb_reset_network_header(skb);
270 skb_put(skb, sizeof(struct ipv6hdr));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700271 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Al Viroae08e1f2006-11-08 00:27:11 -0800273 *(__be32*)hdr = htonl(0x60000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 hdr->payload_len = htons(len);
276 hdr->nexthdr = proto;
277 hdr->hop_limit = np->hop_limit;
278
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000279 hdr->saddr = *saddr;
280 hdr->daddr = *daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
282 return 0;
283}
284
285static int ip6_call_ra_chain(struct sk_buff *skb, int sel)
286{
287 struct ip6_ra_chain *ra;
288 struct sock *last = NULL;
289
290 read_lock(&ip6_ra_lock);
291 for (ra = ip6_ra_chain; ra; ra = ra->next) {
292 struct sock *sk = ra->sk;
Andrew McDonald0bd1b592005-08-09 19:44:42 -0700293 if (sk && ra->sel == sel &&
294 (!sk->sk_bound_dev_if ||
295 sk->sk_bound_dev_if == skb->dev->ifindex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 if (last) {
297 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
298 if (skb2)
299 rawv6_rcv(last, skb2);
300 }
301 last = sk;
302 }
303 }
304
305 if (last) {
306 rawv6_rcv(last, skb);
307 read_unlock(&ip6_ra_lock);
308 return 1;
309 }
310 read_unlock(&ip6_ra_lock);
311 return 0;
312}
313
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700314static int ip6_forward_proxy_check(struct sk_buff *skb)
315{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700316 struct ipv6hdr *hdr = ipv6_hdr(skb);
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700317 u8 nexthdr = hdr->nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800318 __be16 frag_off;
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700319 int offset;
320
321 if (ipv6_ext_hdr(nexthdr)) {
Jesse Gross75f28112011-11-30 17:05:51 -0800322 offset = ipv6_skip_exthdr(skb, sizeof(*hdr), &nexthdr, &frag_off);
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700323 if (offset < 0)
324 return 0;
325 } else
326 offset = sizeof(struct ipv6hdr);
327
328 if (nexthdr == IPPROTO_ICMPV6) {
329 struct icmp6hdr *icmp6;
330
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700331 if (!pskb_may_pull(skb, (skb_network_header(skb) +
332 offset + 1 - skb->data)))
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700333 return 0;
334
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700335 icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset);
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700336
337 switch (icmp6->icmp6_type) {
338 case NDISC_ROUTER_SOLICITATION:
339 case NDISC_ROUTER_ADVERTISEMENT:
340 case NDISC_NEIGHBOUR_SOLICITATION:
341 case NDISC_NEIGHBOUR_ADVERTISEMENT:
342 case NDISC_REDIRECT:
343 /* For reaction involving unicast neighbor discovery
344 * message destined to the proxied address, pass it to
345 * input function.
346 */
347 return 1;
348 default:
349 break;
350 }
351 }
352
Ville Nuorvala74553b02006-09-22 14:42:18 -0700353 /*
354 * The proxying router can't forward traffic sent to a link-local
355 * address, so signal the sender and discard the packet. This
356 * behavior is clarified by the MIPv6 specification.
357 */
358 if (ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) {
359 dst_link_failure(skb);
360 return -1;
361 }
362
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700363 return 0;
364}
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366static inline int ip6_forward_finish(struct sk_buff *skb)
367{
368 return dst_output(skb);
369}
370
371int ip6_forward(struct sk_buff *skb)
372{
Eric Dumazetadf30902009-06-02 05:19:30 +0000373 struct dst_entry *dst = skb_dst(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700374 struct ipv6hdr *hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 struct inet6_skb_parm *opt = IP6CB(skb);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900376 struct net *net = dev_net(dst->dev);
Ulrich Weber14f3ad62010-02-26 04:34:49 -0800377 u32 mtu;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900378
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700379 if (net->ipv6.devconf_all->forwarding == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 goto error;
381
Ben Hutchings4497b072008-06-19 16:22:28 -0700382 if (skb_warn_if_lro(skb))
383 goto drop;
384
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700386 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 goto drop;
388 }
389
Alexey Kuznetsov72b43d02011-01-12 08:34:08 +0000390 if (skb->pkt_type != PACKET_HOST)
391 goto drop;
392
Herbert Xu35fc92a2007-03-26 23:22:20 -0700393 skb_forward_csum(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 /*
396 * We DO NOT make any processing on
397 * RA packets, pushing them to user level AS IS
398 * without ane WARRANTY that application will be able
399 * to interpret them. The reason is that we
400 * cannot make anything clever here.
401 *
402 * We are not end-node, so that if packet contains
403 * AH/ESP, we cannot make anything.
404 * Defragmentation also would be mistake, RA packets
405 * cannot be fragmented, because there is no warranty
406 * that different fragments will go along one path. --ANK
407 */
408 if (opt->ra) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700409 u8 *ptr = skb_network_header(skb) + opt->ra;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 if (ip6_call_ra_chain(skb, (ptr[2]<<8) + ptr[3]))
411 return 0;
412 }
413
414 /*
415 * check and decrement ttl
416 */
417 if (hdr->hop_limit <= 1) {
418 /* Force OUTPUT device used as source address */
419 skb->dev = dst->dev;
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000420 icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT, 0);
Denis V. Lunev483a47d2008-10-08 11:09:27 -0700421 IP6_INC_STATS_BH(net,
422 ip6_dst_idev(dst), IPSTATS_MIB_INHDRERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 kfree_skb(skb);
425 return -ETIMEDOUT;
426 }
427
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700428 /* XXX: idev->cnf.proxy_ndp? */
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700429 if (net->ipv6.devconf_all->proxy_ndp &&
Daniel Lezcano8a3edd82008-03-07 11:14:16 -0800430 pneigh_lookup(&nd_tbl, net, &hdr->daddr, skb->dev, 0)) {
Ville Nuorvala74553b02006-09-22 14:42:18 -0700431 int proxied = ip6_forward_proxy_check(skb);
432 if (proxied > 0)
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700433 return ip6_input(skb);
Ville Nuorvala74553b02006-09-22 14:42:18 -0700434 else if (proxied < 0) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700435 IP6_INC_STATS(net, ip6_dst_idev(dst),
436 IPSTATS_MIB_INDISCARDS);
Ville Nuorvala74553b02006-09-22 14:42:18 -0700437 goto drop;
438 }
Ville Nuorvalae21e0b52006-09-22 14:41:44 -0700439 }
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (!xfrm6_route_forward(skb)) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700442 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_INDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 goto drop;
444 }
Eric Dumazetadf30902009-06-02 05:19:30 +0000445 dst = skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 /* IPv6 specs say nothing about it, but it is clear that we cannot
448 send redirects to source routed frames.
Masahide NAKAMURA1e5dc142007-08-24 19:08:55 +0900449 We don't send redirects to frames decapsulated from IPsec.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 */
David S. Millerc45a3df2012-01-27 15:32:19 -0800451 if (skb->dev == dst->dev && opt->srcrt == 0 && !skb_sec_path(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 struct in6_addr *target = NULL;
David S. Millerfbfe95a2012-06-08 23:24:18 -0700453 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 struct rt6_info *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 /*
457 * incoming and outgoing devices are the same
458 * send a redirect.
459 */
460
461 rt = (struct rt6_info *) dst;
David S. Millerc45a3df2012-01-27 15:32:19 -0800462 if (rt->rt6i_flags & RTF_GATEWAY)
463 target = &rt->rt6i_gateway;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 else
465 target = &hdr->daddr;
466
David S. Millerfbfe95a2012-06-08 23:24:18 -0700467 peer = rt6_get_peer_create(rt);
David S. Miller92d86822011-02-04 15:55:25 -0800468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 /* Limit redirects both by destination (here)
470 and by source (inside ndisc_send_redirect)
471 */
David S. Millerfbfe95a2012-06-08 23:24:18 -0700472 if (inet_peer_xrlim_allow(peer, 1*HZ))
David S. Miller49919692012-01-27 15:30:48 -0800473 ndisc_send_redirect(skb, target);
David L Stevens5bb1ab02007-05-09 13:53:44 -0700474 } else {
475 int addrtype = ipv6_addr_type(&hdr->saddr);
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /* This check is security critical. */
YOSHIFUJI Hideakif81b2e72008-06-25 16:55:26 +0900478 if (addrtype == IPV6_ADDR_ANY ||
479 addrtype & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LOOPBACK))
David L Stevens5bb1ab02007-05-09 13:53:44 -0700480 goto error;
481 if (addrtype & IPV6_ADDR_LINKLOCAL) {
482 icmpv6_send(skb, ICMPV6_DEST_UNREACH,
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000483 ICMPV6_NOT_NEIGHBOUR, 0);
David L Stevens5bb1ab02007-05-09 13:53:44 -0700484 goto error;
485 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487
Ulrich Weber14f3ad62010-02-26 04:34:49 -0800488 mtu = dst_mtu(dst);
489 if (mtu < IPV6_MIN_MTU)
490 mtu = IPV6_MIN_MTU;
491
Herbert Xu0aa68272010-05-27 16:14:30 -0700492 if (skb->len > mtu && !skb_is_gso(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 /* Again, force OUTPUT device used as source address */
494 skb->dev = dst->dev;
Ulrich Weber14f3ad62010-02-26 04:34:49 -0800495 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Denis V. Lunev483a47d2008-10-08 11:09:27 -0700496 IP6_INC_STATS_BH(net,
497 ip6_dst_idev(dst), IPSTATS_MIB_INTOOBIGERRORS);
498 IP6_INC_STATS_BH(net,
499 ip6_dst_idev(dst), IPSTATS_MIB_FRAGFAILS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 kfree_skb(skb);
501 return -EMSGSIZE;
502 }
503
504 if (skb_cow(skb, dst->dev->hard_header_len)) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700505 IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 goto drop;
507 }
508
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700509 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511 /* Mangling hops number delayed to point after skb COW */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900512
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 hdr->hop_limit--;
514
Denis V. Lunev483a47d2008-10-08 11:09:27 -0700515 IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);
Vincent Bernat2d8dbb02012-06-05 03:41:42 +0000516 IP6_ADD_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len);
Jan Engelhardtb2e0b382010-03-23 04:09:07 +0100517 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dst->dev,
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800518 ip6_forward_finish);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520error:
Denis V. Lunev483a47d2008-10-08 11:09:27 -0700521 IP6_INC_STATS_BH(net, ip6_dst_idev(dst), IPSTATS_MIB_INADDRERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522drop:
523 kfree_skb(skb);
524 return -EINVAL;
525}
526
527static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
528{
529 to->pkt_type = from->pkt_type;
530 to->priority = from->priority;
531 to->protocol = from->protocol;
Eric Dumazetadf30902009-06-02 05:19:30 +0000532 skb_dst_drop(to);
533 skb_dst_set(to, dst_clone(skb_dst(from)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 to->dev = from->dev;
Thomas Graf82e91ff2006-11-09 15:19:14 -0800535 to->mark = from->mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537#ifdef CONFIG_NET_SCHED
538 to->tc_index = from->tc_index;
539#endif
Yasuyuki Kozakaie7ac05f2007-03-14 16:44:01 -0700540 nf_copy(to, from);
Jozsef Kadlecsikba9dda32007-07-07 22:21:23 -0700541#if defined(CONFIG_NETFILTER_XT_TARGET_TRACE) || \
542 defined(CONFIG_NETFILTER_XT_TARGET_TRACE_MODULE)
543 to->nf_trace = from->nf_trace;
544#endif
James Morris984bc162006-06-09 00:29:17 -0700545 skb_copy_secmark(to, from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
548int ip6_find_1stfragopt(struct sk_buff *skb, u8 **nexthdr)
549{
550 u16 offset = sizeof(struct ipv6hdr);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700551 struct ipv6_opt_hdr *exthdr =
552 (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700553 unsigned int packet_len = skb->tail - skb->network_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 int found_rhdr = 0;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700555 *nexthdr = &ipv6_hdr(skb)->nexthdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 while (offset + 1 <= packet_len) {
558
559 switch (**nexthdr) {
560
561 case NEXTHDR_HOP:
Masahide NAKAMURA27637df2006-08-23 19:29:47 -0700562 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 case NEXTHDR_ROUTING:
Masahide NAKAMURA27637df2006-08-23 19:29:47 -0700564 found_rhdr = 1;
565 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 case NEXTHDR_DEST:
Masahide NAKAMURA59fbb3a62007-06-26 23:56:32 -0700567#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
Masahide NAKAMURA27637df2006-08-23 19:29:47 -0700568 if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0)
569 break;
570#endif
571 if (found_rhdr)
572 return offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 break;
574 default :
575 return offset;
576 }
Masahide NAKAMURA27637df2006-08-23 19:29:47 -0700577
578 offset += ipv6_optlen(exthdr);
579 *nexthdr = &exthdr->nexthdr;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700580 exthdr = (struct ipv6_opt_hdr *)(skb_network_header(skb) +
581 offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 }
583
584 return offset;
585}
586
Eric Dumazet87c48fa2011-07-21 21:25:58 -0700587void ipv6_select_ident(struct frag_hdr *fhdr, struct rt6_info *rt)
588{
589 static atomic_t ipv6_fragmentation_id;
590 int old, new;
591
Eric Dumazete688a602011-12-22 04:15:53 +0000592 if (rt && !(rt->dst.flags & DST_NOPEER)) {
David S. Millerfbfe95a2012-06-08 23:24:18 -0700593 struct inet_peer *peer = rt6_get_peer_create(rt);
Eric Dumazet87c48fa2011-07-21 21:25:58 -0700594
Eric Dumazet87c48fa2011-07-21 21:25:58 -0700595 if (peer) {
596 fhdr->identification = htonl(inet_getid(peer, 0));
597 return;
598 }
599 }
600 do {
601 old = atomic_read(&ipv6_fragmentation_id);
602 new = old + 1;
603 if (!new)
604 new = 1;
605 } while (atomic_cmpxchg(&ipv6_fragmentation_id, old, new) != old);
606 fhdr->identification = htonl(new);
607}
608
David Stevensad0081e2010-12-17 11:42:42 +0000609int ip6_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 struct sk_buff *frag;
Eric Dumazetadf30902009-06-02 05:19:30 +0000612 struct rt6_info *rt = (struct rt6_info*)skb_dst(skb);
YOSHIFUJI Hideakid91675f2006-02-24 13:18:33 -0800613 struct ipv6_pinfo *np = skb->sk ? inet6_sk(skb->sk) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 struct ipv6hdr *tmp_hdr;
615 struct frag_hdr *fh;
616 unsigned int mtu, hlen, left, len;
Herbert Xua7ae1992011-11-18 02:20:04 +0000617 int hroom, troom;
Al Viroae08e1f2006-11-08 00:27:11 -0800618 __be32 frag_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 int ptr, offset = 0, err=0;
620 u8 *prevhdr, nexthdr = 0;
Eric Dumazetadf30902009-06-02 05:19:30 +0000621 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 hlen = ip6_find_1stfragopt(skb, &prevhdr);
624 nexthdr = *prevhdr;
625
John Heffner628a5c52007-04-20 15:53:27 -0700626 mtu = ip6_skb_dst_mtu(skb);
John Heffnerb881ef72007-04-20 15:52:39 -0700627
628 /* We must not fragment if the socket is set to force MTU discovery
Ulrich Weber14f3ad62010-02-26 04:34:49 -0800629 * or if the skb it not generated by a local socket.
John Heffnerb881ef72007-04-20 15:52:39 -0700630 */
Eric Dumazeta34a1012012-05-18 21:51:44 +0000631 if (unlikely(!skb->local_df && skb->len > mtu)) {
632 if (skb->sk && dst_allfrag(skb_dst(skb)))
633 sk_nocaps_add(skb->sk, NETIF_F_GSO_MASK);
634
Eric Dumazetadf30902009-06-02 05:19:30 +0000635 skb->dev = skb_dst(skb)->dev;
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000636 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Eric Dumazetadf30902009-06-02 05:19:30 +0000637 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700638 IPSTATS_MIB_FRAGFAILS);
John Heffnerb881ef72007-04-20 15:52:39 -0700639 kfree_skb(skb);
640 return -EMSGSIZE;
641 }
642
YOSHIFUJI Hideakid91675f2006-02-24 13:18:33 -0800643 if (np && np->frag_size < mtu) {
644 if (np->frag_size)
645 mtu = np->frag_size;
646 }
647 mtu -= hlen + sizeof(struct frag_hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
David S. Miller21dc3302010-08-23 00:13:46 -0700649 if (skb_has_frag_list(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 int first_len = skb_pagelen(skb);
Eric Dumazet3d130082010-09-21 08:47:45 +0000651 struct sk_buff *frag2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 if (first_len - hlen > mtu ||
654 ((first_len - hlen) & 7) ||
655 skb_cloned(skb))
656 goto slow_path;
657
David S. Miller4d9092b2009-06-09 00:20:05 -0700658 skb_walk_frags(skb, frag) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 /* Correct geometry. */
660 if (frag->len > mtu ||
661 ((frag->len & 7) && frag->next) ||
662 skb_headroom(frag) < hlen)
Eric Dumazet3d130082010-09-21 08:47:45 +0000663 goto slow_path_clean;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 /* Partially cloned skb? */
666 if (skb_shared(frag))
Eric Dumazet3d130082010-09-21 08:47:45 +0000667 goto slow_path_clean;
Herbert Xu2fdba6b2005-05-18 22:52:33 -0700668
669 BUG_ON(frag->sk);
670 if (skb->sk) {
Herbert Xu2fdba6b2005-05-18 22:52:33 -0700671 frag->sk = skb->sk;
672 frag->destructor = sock_wfree;
Herbert Xu2fdba6b2005-05-18 22:52:33 -0700673 }
Eric Dumazet3d130082010-09-21 08:47:45 +0000674 skb->truesize -= frag->truesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
676
677 err = 0;
678 offset = 0;
679 frag = skb_shinfo(skb)->frag_list;
David S. Miller4d9092b2009-06-09 00:20:05 -0700680 skb_frag_list_init(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 /* BUILD HEADER */
682
YOSHIFUJI Hideaki9a217a12006-12-05 13:47:21 -0800683 *prevhdr = NEXTHDR_FRAGMENT;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700684 tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 if (!tmp_hdr) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000686 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700687 IPSTATS_MIB_FRAGFAILS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 return -ENOMEM;
689 }
690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 __skb_pull(skb, hlen);
692 fh = (struct frag_hdr*)__skb_push(skb, sizeof(struct frag_hdr));
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700693 __skb_push(skb, hlen);
694 skb_reset_network_header(skb);
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700695 memcpy(skb_network_header(skb), tmp_hdr, hlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Eric Dumazet87c48fa2011-07-21 21:25:58 -0700697 ipv6_select_ident(fh, rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 fh->nexthdr = nexthdr;
699 fh->reserved = 0;
700 fh->frag_off = htons(IP6_MF);
701 frag_id = fh->identification;
702
703 first_len = skb_pagelen(skb);
704 skb->data_len = first_len - skb_headlen(skb);
705 skb->len = first_len;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700706 ipv6_hdr(skb)->payload_len = htons(first_len -
707 sizeof(struct ipv6hdr));
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900708
Changli Gaod8d1f302010-06-10 23:31:35 -0700709 dst_hold(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
711 for (;;) {
712 /* Prepare header of the next frame,
713 * before previous one went down. */
714 if (frag) {
715 frag->ip_summed = CHECKSUM_NONE;
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -0300716 skb_reset_transport_header(frag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 fh = (struct frag_hdr*)__skb_push(frag, sizeof(struct frag_hdr));
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700718 __skb_push(frag, hlen);
719 skb_reset_network_header(frag);
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700720 memcpy(skb_network_header(frag), tmp_hdr,
721 hlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 offset += skb->len - hlen - sizeof(struct frag_hdr);
723 fh->nexthdr = nexthdr;
724 fh->reserved = 0;
725 fh->frag_off = htons(offset);
726 if (frag->next != NULL)
727 fh->frag_off |= htons(IP6_MF);
728 fh->identification = frag_id;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700729 ipv6_hdr(frag)->payload_len =
730 htons(frag->len -
731 sizeof(struct ipv6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 ip6_copy_metadata(frag, skb);
733 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 err = output(skb);
Wei Dongdafee492006-08-02 13:41:21 -0700736 if(!err)
Changli Gaod8d1f302010-06-10 23:31:35 -0700737 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700738 IPSTATS_MIB_FRAGCREATES);
Wei Dongdafee492006-08-02 13:41:21 -0700739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (err || !frag)
741 break;
742
743 skb = frag;
744 frag = skb->next;
745 skb->next = NULL;
746 }
747
Jesper Juhla51482b2005-11-08 09:41:34 -0800748 kfree(tmp_hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
750 if (err == 0) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700751 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700752 IPSTATS_MIB_FRAGOKS);
Changli Gaod8d1f302010-06-10 23:31:35 -0700753 dst_release(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 return 0;
755 }
756
757 while (frag) {
758 skb = frag->next;
759 kfree_skb(frag);
760 frag = skb;
761 }
762
Changli Gaod8d1f302010-06-10 23:31:35 -0700763 IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700764 IPSTATS_MIB_FRAGFAILS);
Changli Gaod8d1f302010-06-10 23:31:35 -0700765 dst_release(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 return err;
Eric Dumazet3d130082010-09-21 08:47:45 +0000767
768slow_path_clean:
769 skb_walk_frags(skb, frag2) {
770 if (frag2 == frag)
771 break;
772 frag2->sk = NULL;
773 frag2->destructor = NULL;
774 skb->truesize += frag2->truesize;
775 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 }
777
778slow_path:
Eric Dumazet72e843b2012-05-18 11:02:15 +0000779 if ((skb->ip_summed == CHECKSUM_PARTIAL) &&
780 skb_checksum_help(skb))
781 goto fail;
782
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 left = skb->len - hlen; /* Space per frame */
784 ptr = hlen; /* Where to start from */
785
786 /*
787 * Fragment the datagram.
788 */
789
790 *prevhdr = NEXTHDR_FRAGMENT;
Herbert Xua7ae1992011-11-18 02:20:04 +0000791 hroom = LL_RESERVED_SPACE(rt->dst.dev);
792 troom = rt->dst.dev->needed_tailroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794 /*
795 * Keep copying data until we run out.
796 */
797 while(left > 0) {
798 len = left;
799 /* IF: it doesn't fit, use 'mtu' - the data space left */
800 if (len > mtu)
801 len = mtu;
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300802 /* IF: we are not sending up to and including the packet end
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 then align the next start on an eight byte boundary */
804 if (len < left) {
805 len &= ~7;
806 }
807 /*
808 * Allocate buffer.
809 */
810
Herbert Xua7ae1992011-11-18 02:20:04 +0000811 if ((frag = alloc_skb(len + hlen + sizeof(struct frag_hdr) +
812 hroom + troom, GFP_ATOMIC)) == NULL) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700813 NETDEBUG(KERN_INFO "IPv6: frag: no memory for new fragment!\n");
Eric Dumazetadf30902009-06-02 05:19:30 +0000814 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900815 IPSTATS_MIB_FRAGFAILS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 err = -ENOMEM;
817 goto fail;
818 }
819
820 /*
821 * Set up data on packet
822 */
823
824 ip6_copy_metadata(frag, skb);
Herbert Xua7ae1992011-11-18 02:20:04 +0000825 skb_reserve(frag, hroom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 skb_put(frag, len + hlen + sizeof(struct frag_hdr));
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700827 skb_reset_network_header(frag);
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -0300828 fh = (struct frag_hdr *)(skb_network_header(frag) + hlen);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700829 frag->transport_header = (frag->network_header + hlen +
830 sizeof(struct frag_hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 /*
833 * Charge the memory for the fragment to any owner
834 * it might possess
835 */
836 if (skb->sk)
837 skb_set_owner_w(frag, skb->sk);
838
839 /*
840 * Copy the packet header into the new buffer.
841 */
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -0300842 skb_copy_from_linear_data(skb, skb_network_header(frag), hlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 /*
845 * Build fragment header.
846 */
847 fh->nexthdr = nexthdr;
848 fh->reserved = 0;
Yan Zhengf36d6ab2005-10-03 14:19:15 -0700849 if (!frag_id) {
Eric Dumazet87c48fa2011-07-21 21:25:58 -0700850 ipv6_select_ident(fh, rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 frag_id = fh->identification;
852 } else
853 fh->identification = frag_id;
854
855 /*
856 * Copy a block of the IP datagram.
857 */
Wei Yongjun8984e412007-08-21 20:59:08 -0700858 if (skb_copy_bits(skb, ptr, skb_transport_header(frag), len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 BUG();
860 left -= len;
861
862 fh->frag_off = htons(offset);
863 if (left > 0)
864 fh->frag_off |= htons(IP6_MF);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700865 ipv6_hdr(frag)->payload_len = htons(frag->len -
866 sizeof(struct ipv6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 ptr += len;
869 offset += len;
870
871 /*
872 * Put this fragment into the sending queue.
873 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 err = output(frag);
875 if (err)
876 goto fail;
Wei Dongdafee492006-08-02 13:41:21 -0700877
Eric Dumazetadf30902009-06-02 05:19:30 +0000878 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700879 IPSTATS_MIB_FRAGCREATES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 }
Eric Dumazetadf30902009-06-02 05:19:30 +0000881 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900882 IPSTATS_MIB_FRAGOKS);
Eric Dumazet808db802012-04-24 10:17:59 +0000883 consume_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 return err;
885
886fail:
Eric Dumazetadf30902009-06-02 05:19:30 +0000887 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900888 IPSTATS_MIB_FRAGFAILS);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900889 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 return err;
891}
892
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000893static inline int ip6_rt_check(const struct rt6key *rt_key,
894 const struct in6_addr *fl_addr,
895 const struct in6_addr *addr_cache)
YOSHIFUJI Hideakicf6b1982006-08-23 17:19:18 -0700896{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000897 return (rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) &&
898 (addr_cache == NULL || !ipv6_addr_equal(fl_addr, addr_cache));
YOSHIFUJI Hideakicf6b1982006-08-23 17:19:18 -0700899}
900
Herbert Xu497c6152006-07-30 20:19:33 -0700901static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
902 struct dst_entry *dst,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000903 const struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904{
Herbert Xu497c6152006-07-30 20:19:33 -0700905 struct ipv6_pinfo *np = inet6_sk(sk);
906 struct rt6_info *rt = (struct rt6_info *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
Herbert Xu497c6152006-07-30 20:19:33 -0700908 if (!dst)
909 goto out;
910
911 /* Yes, checking route validity in not connected
912 * case is not very simple. Take into account,
913 * that we do not support routing by source, TOS,
914 * and MSG_DONTROUTE --ANK (980726)
915 *
YOSHIFUJI Hideakicf6b1982006-08-23 17:19:18 -0700916 * 1. ip6_rt_check(): If route was host route,
917 * check that cached destination is current.
Herbert Xu497c6152006-07-30 20:19:33 -0700918 * If it is network route, we still may
919 * check its validity using saved pointer
920 * to the last used address: daddr_cache.
921 * We do not want to save whole address now,
922 * (because main consumer of this service
923 * is tcp, which has not this problem),
924 * so that the last trick works only on connected
925 * sockets.
926 * 2. oif also should be the same.
927 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500928 if (ip6_rt_check(&rt->rt6i_dst, &fl6->daddr, np->daddr_cache) ||
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700929#ifdef CONFIG_IPV6_SUBTREES
David S. Miller4c9483b2011-03-12 16:22:43 -0500930 ip6_rt_check(&rt->rt6i_src, &fl6->saddr, np->saddr_cache) ||
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700931#endif
David S. Miller4c9483b2011-03-12 16:22:43 -0500932 (fl6->flowi6_oif && fl6->flowi6_oif != dst->dev->ifindex)) {
Herbert Xu497c6152006-07-30 20:19:33 -0700933 dst_release(dst);
934 dst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 }
936
Herbert Xu497c6152006-07-30 20:19:33 -0700937out:
938 return dst;
939}
940
941static int ip6_dst_lookup_tail(struct sock *sk,
David S. Miller4c9483b2011-03-12 16:22:43 -0500942 struct dst_entry **dst, struct flowi6 *fl6)
Herbert Xu497c6152006-07-30 20:19:33 -0700943{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900944 struct net *net = sock_net(sk);
David S. Miller69cce1d2011-07-17 23:09:49 -0700945#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
946 struct neighbour *n;
947#endif
948 int err;
Herbert Xu497c6152006-07-30 20:19:33 -0700949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 if (*dst == NULL)
David S. Miller4c9483b2011-03-12 16:22:43 -0500951 *dst = ip6_route_output(net, sk, fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
953 if ((err = (*dst)->error))
954 goto out_err_release;
955
David S. Miller4c9483b2011-03-12 16:22:43 -0500956 if (ipv6_addr_any(&fl6->saddr)) {
Daniel Walterc3968a82011-04-13 21:10:57 +0000957 struct rt6_info *rt = (struct rt6_info *) *dst;
958 err = ip6_route_get_saddr(net, rt, &fl6->daddr,
959 sk ? inet6_sk(sk)->srcprefs : 0,
960 &fl6->saddr);
Olaf Hering44456d32005-07-27 11:45:17 -0700961 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 goto out_err_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 }
964
Neil Horman95c385b2007-04-25 17:08:10 -0700965#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
Neil Hormane550dfb2008-09-09 13:51:35 -0700966 /*
967 * Here if the dst entry we've looked up
968 * has a neighbour entry that is in the INCOMPLETE
969 * state and the src address from the flow is
970 * marked as OPTIMISTIC, we release the found
971 * dst entry and replace it instead with the
972 * dst entry of the nexthop router
973 */
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000974 rcu_read_lock();
David Miller27217452011-12-02 16:52:08 +0000975 n = dst_get_neighbour_noref(*dst);
David S. Miller69cce1d2011-07-17 23:09:49 -0700976 if (n && !(n->nud_state & NUD_VALID)) {
Neil Hormane550dfb2008-09-09 13:51:35 -0700977 struct inet6_ifaddr *ifp;
David S. Miller4c9483b2011-03-12 16:22:43 -0500978 struct flowi6 fl_gw6;
Neil Hormane550dfb2008-09-09 13:51:35 -0700979 int redirect;
Neil Horman95c385b2007-04-25 17:08:10 -0700980
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000981 rcu_read_unlock();
David S. Miller4c9483b2011-03-12 16:22:43 -0500982 ifp = ipv6_get_ifaddr(net, &fl6->saddr,
Neil Hormane550dfb2008-09-09 13:51:35 -0700983 (*dst)->dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700984
Neil Hormane550dfb2008-09-09 13:51:35 -0700985 redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);
986 if (ifp)
987 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700988
Neil Hormane550dfb2008-09-09 13:51:35 -0700989 if (redirect) {
990 /*
991 * We need to get the dst entry for the
992 * default router instead
993 */
994 dst_release(*dst);
David S. Miller4c9483b2011-03-12 16:22:43 -0500995 memcpy(&fl_gw6, fl6, sizeof(struct flowi6));
996 memset(&fl_gw6.daddr, 0, sizeof(struct in6_addr));
997 *dst = ip6_route_output(net, sk, &fl_gw6);
Neil Hormane550dfb2008-09-09 13:51:35 -0700998 if ((err = (*dst)->error))
999 goto out_err_release;
Neil Horman95c385b2007-04-25 17:08:10 -07001000 }
Eric Dumazetf2c31e32011-07-29 19:00:53 +00001001 } else {
1002 rcu_read_unlock();
Neil Hormane550dfb2008-09-09 13:51:35 -07001003 }
Neil Horman95c385b2007-04-25 17:08:10 -07001004#endif
1005
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 return 0;
1007
1008out_err_release:
Mitsuru Chinenca46f9c2007-12-05 22:31:47 -08001009 if (err == -ENETUNREACH)
Denis V. Lunev483a47d2008-10-08 11:09:27 -07001010 IP6_INC_STATS_BH(net, NULL, IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 dst_release(*dst);
1012 *dst = NULL;
1013 return err;
1014}
Adrian Bunk34a0b3c2005-11-29 16:28:56 -08001015
Herbert Xu497c6152006-07-30 20:19:33 -07001016/**
1017 * ip6_dst_lookup - perform route lookup on flow
1018 * @sk: socket which provides route info
1019 * @dst: pointer to dst_entry * for result
David S. Miller4c9483b2011-03-12 16:22:43 -05001020 * @fl6: flow to lookup
Herbert Xu497c6152006-07-30 20:19:33 -07001021 *
1022 * This function performs a route lookup on the given flow.
1023 *
1024 * It returns zero on success, or a standard errno code on error.
1025 */
David S. Miller4c9483b2011-03-12 16:22:43 -05001026int ip6_dst_lookup(struct sock *sk, struct dst_entry **dst, struct flowi6 *fl6)
Herbert Xu497c6152006-07-30 20:19:33 -07001027{
1028 *dst = NULL;
David S. Miller4c9483b2011-03-12 16:22:43 -05001029 return ip6_dst_lookup_tail(sk, dst, fl6);
Herbert Xu497c6152006-07-30 20:19:33 -07001030}
Arnaldo Carvalho de Melo3cf3dc62005-12-13 23:23:20 -08001031EXPORT_SYMBOL_GPL(ip6_dst_lookup);
1032
Herbert Xu497c6152006-07-30 20:19:33 -07001033/**
David S. Miller68d0c6d2011-03-01 13:19:07 -08001034 * ip6_dst_lookup_flow - perform route lookup on flow with ipsec
1035 * @sk: socket which provides route info
David S. Miller4c9483b2011-03-12 16:22:43 -05001036 * @fl6: flow to lookup
David S. Miller68d0c6d2011-03-01 13:19:07 -08001037 * @final_dst: final destination address for ipsec lookup
David S. Millera1414712011-03-01 14:32:04 -08001038 * @can_sleep: we are in a sleepable context
David S. Miller68d0c6d2011-03-01 13:19:07 -08001039 *
1040 * This function performs a route lookup on the given flow.
1041 *
1042 * It returns a valid dst pointer on success, or a pointer encoded
1043 * error code.
1044 */
David S. Miller4c9483b2011-03-12 16:22:43 -05001045struct dst_entry *ip6_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
David S. Miller68d0c6d2011-03-01 13:19:07 -08001046 const struct in6_addr *final_dst,
David S. Millera1414712011-03-01 14:32:04 -08001047 bool can_sleep)
David S. Miller68d0c6d2011-03-01 13:19:07 -08001048{
1049 struct dst_entry *dst = NULL;
1050 int err;
1051
David S. Miller4c9483b2011-03-12 16:22:43 -05001052 err = ip6_dst_lookup_tail(sk, &dst, fl6);
David S. Miller68d0c6d2011-03-01 13:19:07 -08001053 if (err)
1054 return ERR_PTR(err);
1055 if (final_dst)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001056 fl6->daddr = *final_dst;
David S. Miller2774c132011-03-01 14:59:04 -08001057 if (can_sleep)
David S. Miller4c9483b2011-03-12 16:22:43 -05001058 fl6->flowi6_flags |= FLOWI_FLAG_CAN_SLEEP;
David S. Miller2774c132011-03-01 14:59:04 -08001059
David S. Miller4c9483b2011-03-12 16:22:43 -05001060 return xfrm_lookup(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller68d0c6d2011-03-01 13:19:07 -08001061}
1062EXPORT_SYMBOL_GPL(ip6_dst_lookup_flow);
1063
1064/**
1065 * ip6_sk_dst_lookup_flow - perform socket cached route lookup on flow
1066 * @sk: socket which provides the dst cache and route info
David S. Miller4c9483b2011-03-12 16:22:43 -05001067 * @fl6: flow to lookup
David S. Miller68d0c6d2011-03-01 13:19:07 -08001068 * @final_dst: final destination address for ipsec lookup
David S. Millera1414712011-03-01 14:32:04 -08001069 * @can_sleep: we are in a sleepable context
Herbert Xu497c6152006-07-30 20:19:33 -07001070 *
1071 * This function performs a route lookup on the given flow with the
1072 * possibility of using the cached route in the socket if it is valid.
1073 * It will take the socket dst lock when operating on the dst cache.
1074 * As a result, this function can only be used in process context.
1075 *
David S. Miller68d0c6d2011-03-01 13:19:07 -08001076 * It returns a valid dst pointer on success, or a pointer encoded
1077 * error code.
Herbert Xu497c6152006-07-30 20:19:33 -07001078 */
David S. Miller4c9483b2011-03-12 16:22:43 -05001079struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
David S. Miller68d0c6d2011-03-01 13:19:07 -08001080 const struct in6_addr *final_dst,
David S. Millera1414712011-03-01 14:32:04 -08001081 bool can_sleep)
Herbert Xu497c6152006-07-30 20:19:33 -07001082{
David S. Miller68d0c6d2011-03-01 13:19:07 -08001083 struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);
1084 int err;
Herbert Xu497c6152006-07-30 20:19:33 -07001085
David S. Miller4c9483b2011-03-12 16:22:43 -05001086 dst = ip6_sk_dst_check(sk, dst, fl6);
David S. Miller68d0c6d2011-03-01 13:19:07 -08001087
David S. Miller4c9483b2011-03-12 16:22:43 -05001088 err = ip6_dst_lookup_tail(sk, &dst, fl6);
David S. Miller68d0c6d2011-03-01 13:19:07 -08001089 if (err)
1090 return ERR_PTR(err);
1091 if (final_dst)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001092 fl6->daddr = *final_dst;
David S. Miller2774c132011-03-01 14:59:04 -08001093 if (can_sleep)
David S. Miller4c9483b2011-03-12 16:22:43 -05001094 fl6->flowi6_flags |= FLOWI_FLAG_CAN_SLEEP;
David S. Miller2774c132011-03-01 14:59:04 -08001095
David S. Miller4c9483b2011-03-12 16:22:43 -05001096 return xfrm_lookup(sock_net(sk), dst, flowi6_to_flowi(fl6), sk, 0);
Herbert Xu497c6152006-07-30 20:19:33 -07001097}
David S. Miller68d0c6d2011-03-01 13:19:07 -08001098EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup_flow);
Herbert Xu497c6152006-07-30 20:19:33 -07001099
Adrian Bunk34a0b3c2005-11-29 16:28:56 -08001100static inline int ip6_ufo_append_data(struct sock *sk,
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001101 int getfrag(void *from, char *to, int offset, int len,
1102 int odd, struct sk_buff *skb),
1103 void *from, int length, int hh_len, int fragheaderlen,
Eric Dumazet87c48fa2011-07-21 21:25:58 -07001104 int transhdrlen, int mtu,unsigned int flags,
1105 struct rt6_info *rt)
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001106
1107{
1108 struct sk_buff *skb;
1109 int err;
1110
1111 /* There is support for UDP large send offload by network
1112 * device, so create one single skb packet containing complete
1113 * udp datagram
1114 */
1115 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL) {
1116 skb = sock_alloc_send_skb(sk,
1117 hh_len + fragheaderlen + transhdrlen + 20,
1118 (flags & MSG_DONTWAIT), &err);
1119 if (skb == NULL)
Zheng Yan504744e2011-10-28 00:26:00 -04001120 return err;
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001121
1122 /* reserve space for Hardware header */
1123 skb_reserve(skb, hh_len);
1124
1125 /* create space for UDP/IP header */
1126 skb_put(skb,fragheaderlen + transhdrlen);
1127
1128 /* initialize network header pointer */
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001129 skb_reset_network_header(skb);
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001130
1131 /* initialize protocol header pointer */
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001132 skb->transport_header = skb->network_header + fragheaderlen;
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001133
Patrick McHardy84fa7932006-08-29 16:44:56 -07001134 skb->ip_summed = CHECKSUM_PARTIAL;
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001135 skb->csum = 0;
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001136 }
1137
1138 err = skb_append_datato_frags(sk,skb, getfrag, from,
1139 (length - transhdrlen));
1140 if (!err) {
1141 struct frag_hdr fhdr;
1142
Sridhar Samudralac31d5322009-07-09 08:09:58 +00001143 /* Specify the length of each IPv6 datagram fragment.
1144 * It has to be a multiple of 8.
1145 */
1146 skb_shinfo(skb)->gso_size = (mtu - fragheaderlen -
1147 sizeof(struct frag_hdr)) & ~7;
Herbert Xuf83ef8c2006-06-30 13:37:03 -07001148 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
Eric Dumazet87c48fa2011-07-21 21:25:58 -07001149 ipv6_select_ident(&fhdr, rt);
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001150 skb_shinfo(skb)->ip6_frag_id = fhdr.identification;
1151 __skb_queue_tail(&sk->sk_write_queue, skb);
1152
1153 return 0;
1154 }
1155 /* There is not enough support do UPD LSO,
1156 * so follow normal path
1157 */
1158 kfree_skb(skb);
1159
1160 return err;
1161}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
Herbert Xu0178b692009-02-05 15:15:50 -08001163static inline struct ipv6_opt_hdr *ip6_opt_dup(struct ipv6_opt_hdr *src,
1164 gfp_t gfp)
1165{
1166 return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1167}
1168
1169static inline struct ipv6_rt_hdr *ip6_rthdr_dup(struct ipv6_rt_hdr *src,
1170 gfp_t gfp)
1171{
1172 return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1173}
1174
Gao feng0c183372012-05-26 01:30:53 +00001175static void ip6_append_data_mtu(int *mtu,
1176 int *maxfraglen,
1177 unsigned int fragheaderlen,
1178 struct sk_buff *skb,
1179 struct rt6_info *rt)
1180{
1181 if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {
1182 if (skb == NULL) {
1183 /* first fragment, reserve header_len */
1184 *mtu = *mtu - rt->dst.header_len;
1185
1186 } else {
1187 /*
1188 * this fragment is not first, the headers
1189 * space is regarded as data space.
1190 */
1191 *mtu = dst_mtu(rt->dst.path);
1192 }
1193 *maxfraglen = ((*mtu - fragheaderlen) & ~7)
1194 + fragheaderlen - sizeof(struct frag_hdr);
1195 }
1196}
1197
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +09001198int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to,
1199 int offset, int len, int odd, struct sk_buff *skb),
1200 void *from, int length, int transhdrlen,
David S. Miller4c9483b2011-03-12 16:22:43 -05001201 int hlimit, int tclass, struct ipv6_txoptions *opt, struct flowi6 *fl6,
Brian Haley13b52cd2010-04-23 11:26:08 +00001202 struct rt6_info *rt, unsigned int flags, int dontfrag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203{
1204 struct inet_sock *inet = inet_sk(sk);
1205 struct ipv6_pinfo *np = inet6_sk(sk);
David S. Millerbdc712b2011-05-06 15:02:07 -07001206 struct inet_cork *cork;
Gao feng0c183372012-05-26 01:30:53 +00001207 struct sk_buff *skb, *skb_prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 unsigned int maxfraglen, fragheaderlen;
1209 int exthdrlen;
Steffen Klassert299b0762011-10-11 01:43:33 +00001210 int dst_exthdrlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 int hh_len;
1212 int mtu;
1213 int copy;
1214 int err;
1215 int offset = 0;
Anders Berggrena693e692011-02-28 12:32:11 -08001216 __u8 tx_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
1218 if (flags&MSG_PROBE)
1219 return 0;
David S. Millerbdc712b2011-05-06 15:02:07 -07001220 cork = &inet->cork.base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 if (skb_queue_empty(&sk->sk_write_queue)) {
1222 /*
1223 * setup for corking
1224 */
1225 if (opt) {
Herbert Xu0178b692009-02-05 15:15:50 -08001226 if (WARN_ON(np->cork.opt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 return -EINVAL;
Herbert Xu0178b692009-02-05 15:15:50 -08001228
1229 np->cork.opt = kmalloc(opt->tot_len, sk->sk_allocation);
1230 if (unlikely(np->cork.opt == NULL))
1231 return -ENOBUFS;
1232
1233 np->cork.opt->tot_len = opt->tot_len;
1234 np->cork.opt->opt_flen = opt->opt_flen;
1235 np->cork.opt->opt_nflen = opt->opt_nflen;
1236
1237 np->cork.opt->dst0opt = ip6_opt_dup(opt->dst0opt,
1238 sk->sk_allocation);
1239 if (opt->dst0opt && !np->cork.opt->dst0opt)
1240 return -ENOBUFS;
1241
1242 np->cork.opt->dst1opt = ip6_opt_dup(opt->dst1opt,
1243 sk->sk_allocation);
1244 if (opt->dst1opt && !np->cork.opt->dst1opt)
1245 return -ENOBUFS;
1246
1247 np->cork.opt->hopopt = ip6_opt_dup(opt->hopopt,
1248 sk->sk_allocation);
1249 if (opt->hopopt && !np->cork.opt->hopopt)
1250 return -ENOBUFS;
1251
1252 np->cork.opt->srcrt = ip6_rthdr_dup(opt->srcrt,
1253 sk->sk_allocation);
1254 if (opt->srcrt && !np->cork.opt->srcrt)
1255 return -ENOBUFS;
1256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 /* need source address above miyazawa*/
1258 }
Changli Gaod8d1f302010-06-10 23:31:35 -07001259 dst_hold(&rt->dst);
David S. Millerbdc712b2011-05-06 15:02:07 -07001260 cork->dst = &rt->dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05001261 inet->cork.fl.u.ip6 = *fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 np->cork.hop_limit = hlimit;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +09001263 np->cork.tclass = tclass;
Gao feng0c183372012-05-26 01:30:53 +00001264 if (rt->dst.flags & DST_XFRM_TUNNEL)
1265 mtu = np->pmtudisc == IPV6_PMTUDISC_PROBE ?
1266 rt->dst.dev->mtu : dst_mtu(&rt->dst);
1267 else
1268 mtu = np->pmtudisc == IPV6_PMTUDISC_PROBE ?
1269 rt->dst.dev->mtu : dst_mtu(rt->dst.path);
Dave Jonesc7503602006-03-20 22:44:52 -08001270 if (np->frag_size < mtu) {
YOSHIFUJI Hideakid91675f2006-02-24 13:18:33 -08001271 if (np->frag_size)
1272 mtu = np->frag_size;
1273 }
David S. Millerbdc712b2011-05-06 15:02:07 -07001274 cork->fragsize = mtu;
Changli Gaod8d1f302010-06-10 23:31:35 -07001275 if (dst_allfrag(rt->dst.path))
David S. Millerbdc712b2011-05-06 15:02:07 -07001276 cork->flags |= IPCORK_ALLFRAG;
1277 cork->length = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 sk->sk_sndmsg_page = NULL;
1279 sk->sk_sndmsg_off = 0;
Steffen Klassert299b0762011-10-11 01:43:33 +00001280 exthdrlen = (opt ? opt->opt_flen : 0) - rt->rt6i_nfheader_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 length += exthdrlen;
1282 transhdrlen += exthdrlen;
Steffen Klassert299b0762011-10-11 01:43:33 +00001283 dst_exthdrlen = rt->dst.header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 } else {
David S. Millerbdc712b2011-05-06 15:02:07 -07001285 rt = (struct rt6_info *)cork->dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05001286 fl6 = &inet->cork.fl.u.ip6;
Herbert Xu0178b692009-02-05 15:15:50 -08001287 opt = np->cork.opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 transhdrlen = 0;
1289 exthdrlen = 0;
Steffen Klassert299b0762011-10-11 01:43:33 +00001290 dst_exthdrlen = 0;
David S. Millerbdc712b2011-05-06 15:02:07 -07001291 mtu = cork->fragsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 }
1293
Changli Gaod8d1f302010-06-10 23:31:35 -07001294 hh_len = LL_RESERVED_SPACE(rt->dst.dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
Masahide NAKAMURAa1b05142007-12-20 20:41:12 -08001296 fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len +
Herbert Xub4ce9272007-11-13 21:33:32 -08001297 (opt ? opt->opt_nflen : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen - sizeof(struct frag_hdr);
1299
1300 if (mtu <= sizeof(struct ipv6hdr) + IPV6_MAXPLEN) {
David S. Millerbdc712b2011-05-06 15:02:07 -07001301 if (cork->length + length > sizeof(struct ipv6hdr) + IPV6_MAXPLEN - fragheaderlen) {
David S. Miller4c9483b2011-03-12 16:22:43 -05001302 ipv6_local_error(sk, EMSGSIZE, fl6, mtu-exthdrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 return -EMSGSIZE;
1304 }
1305 }
1306
Anders Berggrena693e692011-02-28 12:32:11 -08001307 /* For UDP, check if TX timestamp is enabled */
1308 if (sk->sk_type == SOCK_DGRAM) {
1309 err = sock_tx_timestamp(sk, &tx_flags);
1310 if (err)
1311 goto error;
1312 }
1313
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 /*
1315 * Let's try using as much space as possible.
1316 * Use MTU if total length of the message fits into the MTU.
1317 * Otherwise, we need to reserve fragment header and
1318 * fragment alignment (= 8-15 octects, in total).
1319 *
1320 * Note that we may need to "move" the data from the tail of
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001321 * of the buffer to the new fragment when we split
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 * the message.
1323 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001324 * FIXME: It may be fragmented into multiple chunks
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 * at once if non-fragmentable extension headers
1326 * are too large.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001327 * --yoshfuji
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 */
1329
David S. Millerbdc712b2011-05-06 15:02:07 -07001330 cork->length += length;
Brian Haley4b340ae2010-04-23 11:26:09 +00001331 if (length > mtu) {
1332 int proto = sk->sk_protocol;
1333 if (dontfrag && (proto == IPPROTO_UDP || proto == IPPROTO_RAW)){
David S. Miller4c9483b2011-03-12 16:22:43 -05001334 ipv6_local_rxpmtu(sk, fl6, mtu-exthdrlen);
Brian Haley4b340ae2010-04-23 11:26:09 +00001335 return -EMSGSIZE;
1336 }
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001337
Brian Haley4b340ae2010-04-23 11:26:09 +00001338 if (proto == IPPROTO_UDP &&
Changli Gaod8d1f302010-06-10 23:31:35 -07001339 (rt->dst.dev->features & NETIF_F_UFO)) {
Brian Haley4b340ae2010-04-23 11:26:09 +00001340
1341 err = ip6_ufo_append_data(sk, getfrag, from, length,
1342 hh_len, fragheaderlen,
Eric Dumazet87c48fa2011-07-21 21:25:58 -07001343 transhdrlen, mtu, flags, rt);
Brian Haley4b340ae2010-04-23 11:26:09 +00001344 if (err)
1345 goto error;
1346 return 0;
1347 }
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001348 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
1350 if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
1351 goto alloc_new_skb;
1352
1353 while (length > 0) {
1354 /* Check if the remaining data fits into current packet. */
David S. Millerbdc712b2011-05-06 15:02:07 -07001355 copy = (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 if (copy < length)
1357 copy = maxfraglen - skb->len;
1358
1359 if (copy <= 0) {
1360 char *data;
1361 unsigned int datalen;
1362 unsigned int fraglen;
1363 unsigned int fraggap;
1364 unsigned int alloclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365alloc_new_skb:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 /* There's no room in the current skb */
Gao feng0c183372012-05-26 01:30:53 +00001367 if (skb)
1368 fraggap = skb->len - maxfraglen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 else
1370 fraggap = 0;
Gao feng0c183372012-05-26 01:30:53 +00001371 /* update mtu and maxfraglen if necessary */
1372 if (skb == NULL || skb_prev == NULL)
1373 ip6_append_data_mtu(&mtu, &maxfraglen,
1374 fragheaderlen, skb, rt);
1375
1376 skb_prev = skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377
1378 /*
1379 * If remaining data exceeds the mtu,
1380 * we know we need more fragment(s).
1381 */
1382 datalen = length + fraggap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
Gao feng0c183372012-05-26 01:30:53 +00001384 if (datalen > (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen)
1385 datalen = maxfraglen - fragheaderlen - rt->dst.trailer_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 if ((flags & MSG_MORE) &&
Changli Gaod8d1f302010-06-10 23:31:35 -07001387 !(rt->dst.dev->features&NETIF_F_SG))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 alloclen = mtu;
1389 else
1390 alloclen = datalen + fragheaderlen;
1391
Steffen Klassert299b0762011-10-11 01:43:33 +00001392 alloclen += dst_exthdrlen;
1393
Gao feng0c183372012-05-26 01:30:53 +00001394 if (datalen != length + fraggap) {
1395 /*
1396 * this is not the last fragment, the trailer
1397 * space is regarded as data space.
1398 */
1399 datalen += rt->dst.trailer_len;
1400 }
1401
1402 alloclen += rt->dst.trailer_len;
1403 fraglen = datalen + fragheaderlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
1405 /*
1406 * We just reserve space for fragment header.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001407 * Note: this may be overallocation if the message
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 * (without MSG_MORE) fits into the MTU.
1409 */
1410 alloclen += sizeof(struct frag_hdr);
1411
1412 if (transhdrlen) {
1413 skb = sock_alloc_send_skb(sk,
1414 alloclen + hh_len,
1415 (flags & MSG_DONTWAIT), &err);
1416 } else {
1417 skb = NULL;
1418 if (atomic_read(&sk->sk_wmem_alloc) <=
1419 2 * sk->sk_sndbuf)
1420 skb = sock_wmalloc(sk,
1421 alloclen + hh_len, 1,
1422 sk->sk_allocation);
1423 if (unlikely(skb == NULL))
1424 err = -ENOBUFS;
Anders Berggrena693e692011-02-28 12:32:11 -08001425 else {
1426 /* Only the initial fragment
1427 * is time stamped.
1428 */
1429 tx_flags = 0;
1430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 }
1432 if (skb == NULL)
1433 goto error;
1434 /*
1435 * Fill in the control structures
1436 */
Eric Dumazetd7f7c0a2012-05-18 05:37:56 +00001437 skb->ip_summed = CHECKSUM_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 skb->csum = 0;
Gao feng1f858512012-03-19 22:36:10 +00001439 /* reserve for fragmentation and ipsec header */
1440 skb_reserve(skb, hh_len + sizeof(struct frag_hdr) +
1441 dst_exthdrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
Anders Berggrena693e692011-02-28 12:32:11 -08001443 if (sk->sk_type == SOCK_DGRAM)
1444 skb_shinfo(skb)->tx_flags = tx_flags;
1445
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 /*
1447 * Find where to start putting bytes
1448 */
Gao feng1f858512012-03-19 22:36:10 +00001449 data = skb_put(skb, fraglen);
1450 skb_set_network_header(skb, exthdrlen);
1451 data += fragheaderlen;
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001452 skb->transport_header = (skb->network_header +
1453 fragheaderlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 if (fraggap) {
1455 skb->csum = skb_copy_and_csum_bits(
1456 skb_prev, maxfraglen,
1457 data + transhdrlen, fraggap, 0);
1458 skb_prev->csum = csum_sub(skb_prev->csum,
1459 skb->csum);
1460 data += fraggap;
Herbert Xue9fa4f72006-08-13 20:12:58 -07001461 pskb_trim_unique(skb_prev, maxfraglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 }
1463 copy = datalen - transhdrlen - fraggap;
Steffen Klassert299b0762011-10-11 01:43:33 +00001464
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 if (copy < 0) {
1466 err = -EINVAL;
1467 kfree_skb(skb);
1468 goto error;
1469 } else if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
1470 err = -EFAULT;
1471 kfree_skb(skb);
1472 goto error;
1473 }
1474
1475 offset += copy;
1476 length -= datalen - fraggap;
1477 transhdrlen = 0;
1478 exthdrlen = 0;
Steffen Klassert299b0762011-10-11 01:43:33 +00001479 dst_exthdrlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
1481 /*
1482 * Put the packet on the pending queue
1483 */
1484 __skb_queue_tail(&sk->sk_write_queue, skb);
1485 continue;
1486 }
1487
1488 if (copy > length)
1489 copy = length;
1490
Changli Gaod8d1f302010-06-10 23:31:35 -07001491 if (!(rt->dst.dev->features&NETIF_F_SG)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 unsigned int off;
1493
1494 off = skb->len;
1495 if (getfrag(from, skb_put(skb, copy),
1496 offset, copy, off, skb) < 0) {
1497 __skb_trim(skb, off);
1498 err = -EFAULT;
1499 goto error;
1500 }
1501 } else {
1502 int i = skb_shinfo(skb)->nr_frags;
1503 skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];
1504 struct page *page = sk->sk_sndmsg_page;
1505 int off = sk->sk_sndmsg_off;
1506 unsigned int left;
1507
1508 if (page && (left = PAGE_SIZE - off) > 0) {
1509 if (copy >= left)
1510 copy = left;
Ian Campbell408dadf2011-08-22 23:45:00 +00001511 if (page != skb_frag_page(frag)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 if (i == MAX_SKB_FRAGS) {
1513 err = -EMSGSIZE;
1514 goto error;
1515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0);
Ian Campbell408dadf2011-08-22 23:45:00 +00001517 skb_frag_ref(skb, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 frag = &skb_shinfo(skb)->frags[i];
1519 }
1520 } else if(i < MAX_SKB_FRAGS) {
1521 if (copy > PAGE_SIZE)
1522 copy = PAGE_SIZE;
1523 page = alloc_pages(sk->sk_allocation, 0);
1524 if (page == NULL) {
1525 err = -ENOMEM;
1526 goto error;
1527 }
1528 sk->sk_sndmsg_page = page;
1529 sk->sk_sndmsg_off = 0;
1530
1531 skb_fill_page_desc(skb, i, page, 0, 0);
1532 frag = &skb_shinfo(skb)->frags[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 } else {
1534 err = -EMSGSIZE;
1535 goto error;
1536 }
Eric Dumazet9e903e02011-10-18 21:00:24 +00001537 if (getfrag(from,
1538 skb_frag_address(frag) + skb_frag_size(frag),
Ian Campbell408dadf2011-08-22 23:45:00 +00001539 offset, copy, skb->len, skb) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 err = -EFAULT;
1541 goto error;
1542 }
1543 sk->sk_sndmsg_off += copy;
Eric Dumazet9e903e02011-10-18 21:00:24 +00001544 skb_frag_size_add(frag, copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 skb->len += copy;
1546 skb->data_len += copy;
Herbert Xuf945fa72008-01-22 22:39:26 -08001547 skb->truesize += copy;
1548 atomic_add(copy, &sk->sk_wmem_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 }
1550 offset += copy;
1551 length -= copy;
1552 }
1553 return 0;
1554error:
David S. Millerbdc712b2011-05-06 15:02:07 -07001555 cork->length -= length;
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07001556 IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 return err;
1558}
Chris Elstona495f832012-04-29 21:48:53 +00001559EXPORT_SYMBOL_GPL(ip6_append_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
Pavel Emelyanovbf138862007-11-05 21:04:31 -08001561static void ip6_cork_release(struct inet_sock *inet, struct ipv6_pinfo *np)
1562{
Herbert Xu0178b692009-02-05 15:15:50 -08001563 if (np->cork.opt) {
1564 kfree(np->cork.opt->dst0opt);
1565 kfree(np->cork.opt->dst1opt);
1566 kfree(np->cork.opt->hopopt);
1567 kfree(np->cork.opt->srcrt);
1568 kfree(np->cork.opt);
1569 np->cork.opt = NULL;
1570 }
1571
David S. Millerbdc712b2011-05-06 15:02:07 -07001572 if (inet->cork.base.dst) {
1573 dst_release(inet->cork.base.dst);
1574 inet->cork.base.dst = NULL;
1575 inet->cork.base.flags &= ~IPCORK_ALLFRAG;
Pavel Emelyanovbf138862007-11-05 21:04:31 -08001576 }
1577 memset(&inet->cork.fl, 0, sizeof(inet->cork.fl));
1578}
1579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580int ip6_push_pending_frames(struct sock *sk)
1581{
1582 struct sk_buff *skb, *tmp_skb;
1583 struct sk_buff **tail_skb;
1584 struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;
1585 struct inet_sock *inet = inet_sk(sk);
1586 struct ipv6_pinfo *np = inet6_sk(sk);
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07001587 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 struct ipv6hdr *hdr;
1589 struct ipv6_txoptions *opt = np->cork.opt;
David S. Millerbdc712b2011-05-06 15:02:07 -07001590 struct rt6_info *rt = (struct rt6_info *)inet->cork.base.dst;
David S. Miller4c9483b2011-03-12 16:22:43 -05001591 struct flowi6 *fl6 = &inet->cork.fl.u.ip6;
1592 unsigned char proto = fl6->flowi6_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 int err = 0;
1594
1595 if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)
1596 goto out;
1597 tail_skb = &(skb_shinfo(skb)->frag_list);
1598
1599 /* move skb->data to ip header from ext header */
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001600 if (skb->data < skb_network_header(skb))
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -03001601 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
Arnaldo Carvalho de Melocfe1fc72007-03-16 17:26:39 -03001603 __skb_pull(tmp_skb, skb_network_header_len(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 *tail_skb = tmp_skb;
1605 tail_skb = &(tmp_skb->next);
1606 skb->len += tmp_skb->len;
1607 skb->data_len += tmp_skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 skb->truesize += tmp_skb->truesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 tmp_skb->destructor = NULL;
1610 tmp_skb->sk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 }
1612
Herbert Xu28a894532008-02-12 18:07:27 -08001613 /* Allow local fragmentation. */
Herbert Xub5c15fc2008-02-14 23:49:37 -08001614 if (np->pmtudisc < IPV6_PMTUDISC_DO)
Herbert Xu28a894532008-02-12 18:07:27 -08001615 skb->local_df = 1;
1616
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001617 *final_dst = fl6->daddr;
Arnaldo Carvalho de Melocfe1fc72007-03-16 17:26:39 -03001618 __skb_pull(skb, skb_network_header_len(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 if (opt && opt->opt_flen)
1620 ipv6_push_frag_opts(skb, opt, &proto);
1621 if (opt && opt->opt_nflen)
1622 ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst);
1623
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -07001624 skb_push(skb, sizeof(struct ipv6hdr));
1625 skb_reset_network_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001626 hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001627
David S. Miller4c9483b2011-03-12 16:22:43 -05001628 *(__be32*)hdr = fl6->flowlabel |
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +09001629 htonl(0x60000000 | ((int)np->cork.tclass << 20));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 hdr->hop_limit = np->cork.hop_limit;
1632 hdr->nexthdr = proto;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +00001633 hdr->saddr = fl6->saddr;
1634 hdr->daddr = *final_dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
Patrick McHardya2c20642006-01-08 22:37:26 -08001636 skb->priority = sk->sk_priority;
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -08001637 skb->mark = sk->sk_mark;
Patrick McHardya2c20642006-01-08 22:37:26 -08001638
Changli Gaod8d1f302010-06-10 23:31:35 -07001639 skb_dst_set(skb, dst_clone(&rt->dst));
Neil Hormanedf391f2009-04-27 02:45:02 -07001640 IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
David L Stevens14878f72007-09-16 16:52:35 -07001641 if (proto == IPPROTO_ICMPV6) {
Eric Dumazetadf30902009-06-02 05:19:30 +00001642 struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
David L Stevens14878f72007-09-16 16:52:35 -07001643
Denis V. Lunev5a57d4c2008-10-08 10:34:14 -07001644 ICMP6MSGOUT_INC_STATS_BH(net, idev, icmp6_hdr(skb)->icmp6_type);
Denis V. Luneve41b5362008-10-08 10:33:26 -07001645 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS);
David L Stevens14878f72007-09-16 16:52:35 -07001646 }
1647
Herbert Xuef76bc22008-01-11 19:15:08 -08001648 err = ip6_local_out(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 if (err) {
1650 if (err > 0)
Eric Dumazet6ce9e7b2009-09-02 18:05:33 -07001651 err = net_xmit_errno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 if (err)
1653 goto error;
1654 }
1655
1656out:
Pavel Emelyanovbf138862007-11-05 21:04:31 -08001657 ip6_cork_release(inet, np);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 return err;
1659error:
Eric Dumazet06254912009-09-01 18:37:16 -07001660 IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 goto out;
1662}
Chris Elstona495f832012-04-29 21:48:53 +00001663EXPORT_SYMBOL_GPL(ip6_push_pending_frames);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664
1665void ip6_flush_pending_frames(struct sock *sk)
1666{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 struct sk_buff *skb;
1668
1669 while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL) {
Eric Dumazetadf30902009-06-02 05:19:30 +00001670 if (skb_dst(skb))
1671 IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb_dst(skb)),
YOSHIFUJI Hideakie1f522082007-09-11 11:31:43 +02001672 IPSTATS_MIB_OUTDISCARDS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 kfree_skb(skb);
1674 }
1675
Pavel Emelyanovbf138862007-11-05 21:04:31 -08001676 ip6_cork_release(inet_sk(sk), inet6_sk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677}
Chris Elstona495f832012-04-29 21:48:53 +00001678EXPORT_SYMBOL_GPL(ip6_flush_pending_frames);