?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.11-rc6
[linux/fpc-iii.git] / net / ipv4 / ip_tunnel.c
blob823abaef006bd353cf0466f14dd3abaa26f80c07
1 /*
2 * Copyright (c) 2013 Nicira, Inc.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of version 2 of the GNU General Public
6 * License as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16 * 02110-1301, USA
17 */
18
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21 #include <linux/capability.h>
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 #include <linux/skbuff.h>
28 #include <linux/netdevice.h>
29 #include <linux/in.h>
30 #include <linux/tcp.h>
31 #include <linux/udp.h>
32 #include <linux/if_arp.h>
33 #include <linux/init.h>
34 #include <linux/in6.h>
35 #include <linux/inetdevice.h>
36 #include <linux/igmp.h>
37 #include <linux/netfilter_ipv4.h>
38 #include <linux/etherdevice.h>
39 #include <linux/if_ether.h>
40 #include <linux/if_vlan.h>
41 #include <linux/rculist.h>
42 #include <linux/err.h>
43
44 #include <net/sock.h>
45 #include <net/ip.h>
46 #include <net/icmp.h>
47 #include <net/protocol.h>
48 #include <net/ip_tunnels.h>
49 #include <net/arp.h>
50 #include <net/checksum.h>
51 #include <net/dsfield.h>
52 #include <net/inet_ecn.h>
53 #include <net/xfrm.h>
54 #include <net/net_namespace.h>
55 #include <net/netns/generic.h>
56 #include <net/rtnetlink.h>
57 #include <net/udp.h>
58 #include <net/dst_metadata.h>
59
60 #if IS_ENABLED(CONFIG_IPV6)
61 #include <net/ipv6.h>
62 #include <net/ip6_fib.h>
63 #include <net/ip6_route.h>
64 #endif
65
66 static unsigned int ip_tunnel_hash(__be32 key, __be32 remote)
67 {
68 return hash_32((__force u32)key ^ (__force u32)remote,
69 IP_TNL_HASH_BITS);
70 }
71
72 static bool ip_tunnel_key_match(const struct ip_tunnel_parm *p,
73 __be16 flags, __be32 key)
74 {
75 if (p->i_flags & TUNNEL_KEY) {
76 if (flags & TUNNEL_KEY)
77 return key == p->i_key;
78 else
79 /* key expected, none present */
80 return false;
81 } else
82 return !(flags & TUNNEL_KEY);
83 }
84
85 /* Fallback tunnel: no source, no destination, no key, no options
86
87 Tunnel hash table:
88 We require exact key match i.e. if a key is present in packet
89 it will match only tunnel with the same key; if it is not present,
90 it will match only keyless tunnel.
91
92 All keysless packets, if not matched configured keyless tunnels
93 will match fallback tunnel.
94 Given src, dst and key, find appropriate for input tunnel.
95 */
96 struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
97 int link, __be16 flags,
98 __be32 remote, __be32 local,
99 __be32 key)
100 {
101 unsigned int hash;
102 struct ip_tunnel *t, *cand = NULL;
103 struct hlist_head *head;
104
105 hash = ip_tunnel_hash(key, remote);
106 head = &itn->tunnels[hash];
107
108 hlist_for_each_entry_rcu(t, head, hash_node) {
109 if (local != t->parms.iph.saddr ||
110 remote != t->parms.iph.daddr ||
111 !(t->dev->flags & IFF_UP))
112 continue;
113
114 if (!ip_tunnel_key_match(&t->parms, flags, key))
115 continue;
116
117 if (t->parms.link == link)
118 return t;
119 else
120 cand = t;
121 }
122
123 hlist_for_each_entry_rcu(t, head, hash_node) {
124 if (remote != t->parms.iph.daddr ||
125 t->parms.iph.saddr != 0 ||
126 !(t->dev->flags & IFF_UP))
127 continue;
128
129 if (!ip_tunnel_key_match(&t->parms, flags, key))
130 continue;
131
132 if (t->parms.link == link)
133 return t;
134 else if (!cand)
135 cand = t;
136 }
137
138 hash = ip_tunnel_hash(key, 0);
139 head = &itn->tunnels[hash];
140
141 hlist_for_each_entry_rcu(t, head, hash_node) {
142 if ((local != t->parms.iph.saddr || t->parms.iph.daddr != 0) &&
143 (local != t->parms.iph.daddr || !ipv4_is_multicast(local)))
144 continue;
145
146 if (!(t->dev->flags & IFF_UP))
147 continue;
148
149 if (!ip_tunnel_key_match(&t->parms, flags, key))
150 continue;
151
152 if (t->parms.link == link)
153 return t;
154 else if (!cand)
155 cand = t;
156 }
157
158 if (flags & TUNNEL_NO_KEY)
159 goto skip_key_lookup;
160
161 hlist_for_each_entry_rcu(t, head, hash_node) {
162 if (t->parms.i_key != key ||
163 t->parms.iph.saddr != 0 ||
164 t->parms.iph.daddr != 0 ||
165 !(t->dev->flags & IFF_UP))
166 continue;
167
168 if (t->parms.link == link)
169 return t;
170 else if (!cand)
171 cand = t;
172 }
173
174 skip_key_lookup:
175 if (cand)
176 return cand;
177
178 t = rcu_dereference(itn->collect_md_tun);
179 if (t)
180 return t;
181
182 if (itn->fb_tunnel_dev && itn->fb_tunnel_dev->flags & IFF_UP)
183 return netdev_priv(itn->fb_tunnel_dev);
184
185 return NULL;
186 }
187 EXPORT_SYMBOL_GPL(ip_tunnel_lookup);
188
189 static struct hlist_head *ip_bucket(struct ip_tunnel_net *itn,
190 struct ip_tunnel_parm *parms)
191 {
192 unsigned int h;
193 __be32 remote;
194 __be32 i_key = parms->i_key;
195
196 if (parms->iph.daddr && !ipv4_is_multicast(parms->iph.daddr))
197 remote = parms->iph.daddr;
198 else
199 remote = 0;
200
201 if (!(parms->i_flags & TUNNEL_KEY) && (parms->i_flags & VTI_ISVTI))
202 i_key = 0;
203
204 h = ip_tunnel_hash(i_key, remote);
205 return &itn->tunnels[h];
206 }
207
208 static void ip_tunnel_add(struct ip_tunnel_net *itn, struct ip_tunnel *t)
209 {
210 struct hlist_head *head = ip_bucket(itn, &t->parms);
211
212 if (t->collect_md)
213 rcu_assign_pointer(itn->collect_md_tun, t);
214 hlist_add_head_rcu(&t->hash_node, head);
215 }
216
217 static void ip_tunnel_del(struct ip_tunnel_net *itn, struct ip_tunnel *t)
218 {
219 if (t->collect_md)
220 rcu_assign_pointer(itn->collect_md_tun, NULL);
221 hlist_del_init_rcu(&t->hash_node);
222 }
223
224 static struct ip_tunnel *ip_tunnel_find(struct ip_tunnel_net *itn,
225 struct ip_tunnel_parm *parms,
226 int type)
227 {
228 __be32 remote = parms->iph.daddr;
229 __be32 local = parms->iph.saddr;
230 __be32 key = parms->i_key;
231 __be16 flags = parms->i_flags;
232 int link = parms->link;
233 struct ip_tunnel *t = NULL;
234 struct hlist_head *head = ip_bucket(itn, parms);
235
236 hlist_for_each_entry_rcu(t, head, hash_node) {
237 if (local == t->parms.iph.saddr &&
238 remote == t->parms.iph.daddr &&
239 link == t->parms.link &&
240 type == t->dev->type &&
241 ip_tunnel_key_match(&t->parms, flags, key))
242 break;
243 }
244 return t;
245 }
246
247 static struct net_device *__ip_tunnel_create(struct net *net,
248 const struct rtnl_link_ops *ops,
249 struct ip_tunnel_parm *parms)
250 {
251 int err;
252 struct ip_tunnel *tunnel;
253 struct net_device *dev;
254 char name[IFNAMSIZ];
255
256 if (parms->name[0])
257 strlcpy(name, parms->name, IFNAMSIZ);
258 else {
259 if (strlen(ops->kind) > (IFNAMSIZ - 3)) {
260 err = -E2BIG;
261 goto failed;
262 }
263 strlcpy(name, ops->kind, IFNAMSIZ);
264 strncat(name, "%d", 2);
265 }
266
267 ASSERT_RTNL();
268 dev = alloc_netdev(ops->priv_size, name, NET_NAME_UNKNOWN, ops->setup);
269 if (!dev) {
270 err = -ENOMEM;
271 goto failed;
272 }
273 dev_net_set(dev, net);
274
275 dev->rtnl_link_ops = ops;
276
277 tunnel = netdev_priv(dev);
278 tunnel->parms = *parms;
279 tunnel->net = net;
280
281 err = register_netdevice(dev);
282 if (err)
283 goto failed_free;
284
285 return dev;
286
287 failed_free:
288 free_netdev(dev);
289 failed:
290 return ERR_PTR(err);
291 }
292
293 static inline void init_tunnel_flow(struct flowi4 *fl4,
294 int proto,
295 __be32 daddr, __be32 saddr,
296 __be32 key, __u8 tos, int oif)
297 {
298 memset(fl4, 0, sizeof(*fl4));
299 fl4->flowi4_oif = oif;
300 fl4->daddr = daddr;
301 fl4->saddr = saddr;
302 fl4->flowi4_tos = tos;
303 fl4->flowi4_proto = proto;
304 fl4->fl4_gre_key = key;
305 }
306
307 static int ip_tunnel_bind_dev(struct net_device *dev)
308 {
309 struct net_device *tdev = NULL;
310 struct ip_tunnel *tunnel = netdev_priv(dev);
311 const struct iphdr *iph;
312 int hlen = LL_MAX_HEADER;
313 int mtu = ETH_DATA_LEN;
314 int t_hlen = tunnel->hlen + sizeof(struct iphdr);
315
316 iph = &tunnel->parms.iph;
317
318 /* Guess output device to choose reasonable mtu and needed_headroom */
319 if (iph->daddr) {
320 struct flowi4 fl4;
321 struct rtable *rt;
322
323 init_tunnel_flow(&fl4, iph->protocol, iph->daddr,
324 iph->saddr, tunnel->parms.o_key,
325 RT_TOS(iph->tos), tunnel->parms.link);
326 rt = ip_route_output_key(tunnel->net, &fl4);
327
328 if (!IS_ERR(rt)) {
329 tdev = rt->dst.dev;
330 ip_rt_put(rt);
331 }
332 if (dev->type != ARPHRD_ETHER)
333 dev->flags |= IFF_POINTOPOINT;
334
335 dst_cache_reset(&tunnel->dst_cache);
336 }
337
338 if (!tdev && tunnel->parms.link)
339 tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
340
341 if (tdev) {
342 hlen = tdev->hard_header_len + tdev->needed_headroom;
343 mtu = tdev->mtu;
344 }
345
346 dev->needed_headroom = t_hlen + hlen;
347 mtu -= (dev->hard_header_len + t_hlen);
348
349 if (mtu < 68)
350 mtu = 68;
351
352 return mtu;
353 }
354
355 static struct ip_tunnel *ip_tunnel_create(struct net *net,
356 struct ip_tunnel_net *itn,
357 struct ip_tunnel_parm *parms)
358 {
359 struct ip_tunnel *nt;
360 struct net_device *dev;
361 int t_hlen;
362
363 BUG_ON(!itn->fb_tunnel_dev);
364 dev = __ip_tunnel_create(net, itn->fb_tunnel_dev->rtnl_link_ops, parms);
365 if (IS_ERR(dev))
366 return ERR_CAST(dev);
367
368 dev->mtu = ip_tunnel_bind_dev(dev);
369
370 nt = netdev_priv(dev);
371 t_hlen = nt->hlen + sizeof(struct iphdr);
372 dev->min_mtu = ETH_MIN_MTU;
373 dev->max_mtu = 0xFFF8 - dev->hard_header_len - t_hlen;
374 ip_tunnel_add(itn, nt);
375 return nt;
376 }
377
378 int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
379 const struct tnl_ptk_info *tpi, struct metadata_dst *tun_dst,
380 bool log_ecn_error)
381 {
382 struct pcpu_sw_netstats *tstats;
383 const struct iphdr *iph = ip_hdr(skb);
384 int err;
385
386 #ifdef CONFIG_NET_IPGRE_BROADCAST
387 if (ipv4_is_multicast(iph->daddr)) {
388 tunnel->dev->stats.multicast++;
389 skb->pkt_type = PACKET_BROADCAST;
390 }
391 #endif
392
393 if ((!(tpi->flags&TUNNEL_CSUM) && (tunnel->parms.i_flags&TUNNEL_CSUM)) ||
394 ((tpi->flags&TUNNEL_CSUM) && !(tunnel->parms.i_flags&TUNNEL_CSUM))) {
395 tunnel->dev->stats.rx_crc_errors++;
396 tunnel->dev->stats.rx_errors++;
397 goto drop;
398 }
399
400 if (tunnel->parms.i_flags&TUNNEL_SEQ) {
401 if (!(tpi->flags&TUNNEL_SEQ) ||
402 (tunnel->i_seqno && (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {
403 tunnel->dev->stats.rx_fifo_errors++;
404 tunnel->dev->stats.rx_errors++;
405 goto drop;
406 }
407 tunnel->i_seqno = ntohl(tpi->seq) + 1;
408 }
409
410 skb_reset_network_header(skb);
411
412 err = IP_ECN_decapsulate(iph, skb);
413 if (unlikely(err)) {
414 if (log_ecn_error)
415 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
416 &iph->saddr, iph->tos);
417 if (err > 1) {
418 ++tunnel->dev->stats.rx_frame_errors;
419 ++tunnel->dev->stats.rx_errors;
420 goto drop;
421 }
422 }
423
424 tstats = this_cpu_ptr(tunnel->dev->tstats);
425 u64_stats_update_begin(&tstats->syncp);
426 tstats->rx_packets++;
427 tstats->rx_bytes += skb->len;
428 u64_stats_update_end(&tstats->syncp);
429
430 skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));
431
432 if (tunnel->dev->type == ARPHRD_ETHER) {
433 skb->protocol = eth_type_trans(skb, tunnel->dev);
434 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
435 } else {
436 skb->dev = tunnel->dev;
437 }
438
439 if (tun_dst)
440 skb_dst_set(skb, (struct dst_entry *)tun_dst);
441
442 gro_cells_receive(&tunnel->gro_cells, skb);
443 return 0;
444
445 drop:
446 kfree_skb(skb);
447 return 0;
448 }
449 EXPORT_SYMBOL_GPL(ip_tunnel_rcv);
450
451 int ip_tunnel_encap_add_ops(const struct ip_tunnel_encap_ops *ops,
452 unsigned int num)
453 {
454 if (num >= MAX_IPTUN_ENCAP_OPS)
455 return -ERANGE;
456
457 return !cmpxchg((const struct ip_tunnel_encap_ops **)
458 &iptun_encaps[num],
459 NULL, ops) ? 0 : -1;
460 }
461 EXPORT_SYMBOL(ip_tunnel_encap_add_ops);
462
463 int ip_tunnel_encap_del_ops(const struct ip_tunnel_encap_ops *ops,
464 unsigned int num)
465 {
466 int ret;
467
468 if (num >= MAX_IPTUN_ENCAP_OPS)
469 return -ERANGE;
470
471 ret = (cmpxchg((const struct ip_tunnel_encap_ops **)
472 &iptun_encaps[num],
473 ops, NULL) == ops) ? 0 : -1;
474
475 synchronize_net();
476
477 return ret;
478 }
479 EXPORT_SYMBOL(ip_tunnel_encap_del_ops);
480
481 int ip_tunnel_encap_setup(struct ip_tunnel *t,
482 struct ip_tunnel_encap *ipencap)
483 {
484 int hlen;
485
486 memset(&t->encap, 0, sizeof(t->encap));
487
488 hlen = ip_encap_hlen(ipencap);
489 if (hlen < 0)
490 return hlen;
491
492 t->encap.type = ipencap->type;
493 t->encap.sport = ipencap->sport;
494 t->encap.dport = ipencap->dport;
495 t->encap.flags = ipencap->flags;
496
497 t->encap_hlen = hlen;
498 t->hlen = t->encap_hlen + t->tun_hlen;
499
500 return 0;
501 }
502 EXPORT_SYMBOL_GPL(ip_tunnel_encap_setup);
503
504 static int tnl_update_pmtu(struct net_device *dev, struct sk_buff *skb,
505 struct rtable *rt, __be16 df,
506 const struct iphdr *inner_iph)
507 {
508 struct ip_tunnel *tunnel = netdev_priv(dev);
509 int pkt_size = skb->len - tunnel->hlen - dev->hard_header_len;
510 int mtu;
511
512 if (df)
513 mtu = dst_mtu(&rt->dst) - dev->hard_header_len
514 - sizeof(struct iphdr) - tunnel->hlen;
515 else
516 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
517
518 if (skb_dst(skb))
519 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
520
521 if (skb->protocol == htons(ETH_P_IP)) {
522 if (!skb_is_gso(skb) &&
523 (inner_iph->frag_off & htons(IP_DF)) &&
524 mtu < pkt_size) {
525 memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
526 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
527 return -E2BIG;
528 }
529 }
530 #if IS_ENABLED(CONFIG_IPV6)
531 else if (skb->protocol == htons(ETH_P_IPV6)) {
532 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
533
534 if (rt6 && mtu < dst_mtu(skb_dst(skb)) &&
535 mtu >= IPV6_MIN_MTU) {
536 if ((tunnel->parms.iph.daddr &&
537 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
538 rt6->rt6i_dst.plen == 128) {
539 rt6->rt6i_flags |= RTF_MODIFIED;
540 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
541 }
542 }
543
544 if (!skb_is_gso(skb) && mtu >= IPV6_MIN_MTU &&
545 mtu < pkt_size) {
546 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
547 return -E2BIG;
548 }
549 }
550 #endif
551 return 0;
552 }
553
554 void ip_md_tunnel_xmit(struct sk_buff *skb, struct net_device *dev, u8 proto)
555 {
556 struct ip_tunnel *tunnel = netdev_priv(dev);
557 u32 headroom = sizeof(struct iphdr);
558 struct ip_tunnel_info *tun_info;
559 const struct ip_tunnel_key *key;
560 const struct iphdr *inner_iph;
561 struct rtable *rt;
562 struct flowi4 fl4;
563 __be16 df = 0;
564 u8 tos, ttl;
565
566 tun_info = skb_tunnel_info(skb);
567 if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
568 ip_tunnel_info_af(tun_info) != AF_INET))
569 goto tx_error;
570 key = &tun_info->key;
571 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
572 inner_iph = (const struct iphdr *)skb_inner_network_header(skb);
573 tos = key->tos;
574 if (tos == 1) {
575 if (skb->protocol == htons(ETH_P_IP))
576 tos = inner_iph->tos;
577 else if (skb->protocol == htons(ETH_P_IPV6))
578 tos = ipv6_get_dsfield((const struct ipv6hdr *)inner_iph);
579 }
580 init_tunnel_flow(&fl4, proto, key->u.ipv4.dst, key->u.ipv4.src, 0,
581 RT_TOS(tos), tunnel->parms.link);
582 if (tunnel->encap.type != TUNNEL_ENCAP_NONE)
583 goto tx_error;
584 rt = ip_route_output_key(tunnel->net, &fl4);
585 if (IS_ERR(rt)) {
586 dev->stats.tx_carrier_errors++;
587 goto tx_error;
588 }
589 if (rt->dst.dev == dev) {
590 ip_rt_put(rt);
591 dev->stats.collisions++;
592 goto tx_error;
593 }
594 tos = ip_tunnel_ecn_encap(tos, inner_iph, skb);
595 ttl = key->ttl;
596 if (ttl == 0) {
597 if (skb->protocol == htons(ETH_P_IP))
598 ttl = inner_iph->ttl;
599 else if (skb->protocol == htons(ETH_P_IPV6))
600 ttl = ((const struct ipv6hdr *)inner_iph)->hop_limit;
601 else
602 ttl = ip4_dst_hoplimit(&rt->dst);
603 }
604 if (key->tun_flags & TUNNEL_DONT_FRAGMENT)
605 df = htons(IP_DF);
606 else if (skb->protocol == htons(ETH_P_IP))
607 df = inner_iph->frag_off & htons(IP_DF);
608 headroom += LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len;
609 if (headroom > dev->needed_headroom)
610 dev->needed_headroom = headroom;
611
612 if (skb_cow_head(skb, dev->needed_headroom)) {
613 ip_rt_put(rt);
614 goto tx_dropped;
615 }
616 iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, proto, key->tos,
617 key->ttl, df, !net_eq(tunnel->net, dev_net(dev)));
618 return;
619 tx_error:
620 dev->stats.tx_errors++;
621 goto kfree;
622 tx_dropped:
623 dev->stats.tx_dropped++;
624 kfree:
625 kfree_skb(skb);
626 }
627 EXPORT_SYMBOL_GPL(ip_md_tunnel_xmit);
628
629 void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
630 const struct iphdr *tnl_params, u8 protocol)
631 {
632 struct ip_tunnel *tunnel = netdev_priv(dev);
633 const struct iphdr *inner_iph;
634 struct flowi4 fl4;
635 u8 tos, ttl;
636 __be16 df;
637 struct rtable *rt; /* Route to the other host */
638 unsigned int max_headroom; /* The extra header space needed */
639 __be32 dst;
640 bool connected;
641
642 inner_iph = (const struct iphdr *)skb_inner_network_header(skb);
643 connected = (tunnel->parms.iph.daddr != 0);
644
645 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
646
647 dst = tnl_params->daddr;
648 if (dst == 0) {
649 /* NBMA tunnel */
650
651 if (!skb_dst(skb)) {
652 dev->stats.tx_fifo_errors++;
653 goto tx_error;
654 }
655
656 if (skb->protocol == htons(ETH_P_IP)) {
657 rt = skb_rtable(skb);
658 dst = rt_nexthop(rt, inner_iph->daddr);
659 }
660 #if IS_ENABLED(CONFIG_IPV6)
661 else if (skb->protocol == htons(ETH_P_IPV6)) {
662 const struct in6_addr *addr6;
663 struct neighbour *neigh;
664 bool do_tx_error_icmp;
665 int addr_type;
666
667 neigh = dst_neigh_lookup(skb_dst(skb),
668 &ipv6_hdr(skb)->daddr);
669 if (!neigh)
670 goto tx_error;
671
672 addr6 = (const struct in6_addr *)&neigh->primary_key;
673 addr_type = ipv6_addr_type(addr6);
674
675 if (addr_type == IPV6_ADDR_ANY) {
676 addr6 = &ipv6_hdr(skb)->daddr;
677 addr_type = ipv6_addr_type(addr6);
678 }
679
680 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
681 do_tx_error_icmp = true;
682 else {
683 do_tx_error_icmp = false;
684 dst = addr6->s6_addr32[3];
685 }
686 neigh_release(neigh);
687 if (do_tx_error_icmp)
688 goto tx_error_icmp;
689 }
690 #endif
691 else
692 goto tx_error;
693
694 connected = false;
695 }
696
697 tos = tnl_params->tos;
698 if (tos & 0x1) {
699 tos &= ~0x1;
700 if (skb->protocol == htons(ETH_P_IP)) {
701 tos = inner_iph->tos;
702 connected = false;
703 } else if (skb->protocol == htons(ETH_P_IPV6)) {
704 tos = ipv6_get_dsfield((const struct ipv6hdr *)inner_iph);
705 connected = false;
706 }
707 }
708
709 init_tunnel_flow(&fl4, protocol, dst, tnl_params->saddr,
710 tunnel->parms.o_key, RT_TOS(tos), tunnel->parms.link);
711
712 if (ip_tunnel_encap(skb, tunnel, &protocol, &fl4) < 0)
713 goto tx_error;
714
715 rt = connected ? dst_cache_get_ip4(&tunnel->dst_cache, &fl4.saddr) :
716 NULL;
717
718 if (!rt) {
719 rt = ip_route_output_key(tunnel->net, &fl4);
720
721 if (IS_ERR(rt)) {
722 dev->stats.tx_carrier_errors++;
723 goto tx_error;
724 }
725 if (connected)
726 dst_cache_set_ip4(&tunnel->dst_cache, &rt->dst,
727 fl4.saddr);
728 }
729
730 if (rt->dst.dev == dev) {
731 ip_rt_put(rt);
732 dev->stats.collisions++;
733 goto tx_error;
734 }
735
736 if (tnl_update_pmtu(dev, skb, rt, tnl_params->frag_off, inner_iph)) {
737 ip_rt_put(rt);
738 goto tx_error;
739 }
740
741 if (tunnel->err_count > 0) {
742 if (time_before(jiffies,
743 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
744 tunnel->err_count--;
745
746 dst_link_failure(skb);
747 } else
748 tunnel->err_count = 0;
749 }
750
751 tos = ip_tunnel_ecn_encap(tos, inner_iph, skb);
752 ttl = tnl_params->ttl;
753 if (ttl == 0) {
754 if (skb->protocol == htons(ETH_P_IP))
755 ttl = inner_iph->ttl;
756 #if IS_ENABLED(CONFIG_IPV6)
757 else if (skb->protocol == htons(ETH_P_IPV6))
758 ttl = ((const struct ipv6hdr *)inner_iph)->hop_limit;
759 #endif
760 else
761 ttl = ip4_dst_hoplimit(&rt->dst);
762 }
763
764 df = tnl_params->frag_off;
765 if (skb->protocol == htons(ETH_P_IP) && !tunnel->ignore_df)
766 df |= (inner_iph->frag_off&htons(IP_DF));
767
768 max_headroom = LL_RESERVED_SPACE(rt->dst.dev) + sizeof(struct iphdr)
769 + rt->dst.header_len + ip_encap_hlen(&tunnel->encap);
770 if (max_headroom > dev->needed_headroom)
771 dev->needed_headroom = max_headroom;
772
773 if (skb_cow_head(skb, dev->needed_headroom)) {
774 ip_rt_put(rt);
775 dev->stats.tx_dropped++;
776 kfree_skb(skb);
777 return;
778 }
779
780 iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, protocol, tos, ttl,
781 df, !net_eq(tunnel->net, dev_net(dev)));
782 return;
783
784 #if IS_ENABLED(CONFIG_IPV6)
785 tx_error_icmp:
786 dst_link_failure(skb);
787 #endif
788 tx_error:
789 dev->stats.tx_errors++;
790 kfree_skb(skb);
791 }
792 EXPORT_SYMBOL_GPL(ip_tunnel_xmit);
793
794 static void ip_tunnel_update(struct ip_tunnel_net *itn,
795 struct ip_tunnel *t,
796 struct net_device *dev,
797 struct ip_tunnel_parm *p,
798 bool set_mtu)
799 {
800 ip_tunnel_del(itn, t);
801 t->parms.iph.saddr = p->iph.saddr;
802 t->parms.iph.daddr = p->iph.daddr;
803 t->parms.i_key = p->i_key;
804 t->parms.o_key = p->o_key;
805 if (dev->type != ARPHRD_ETHER) {
806 memcpy(dev->dev_addr, &p->iph.saddr, 4);
807 memcpy(dev->broadcast, &p->iph.daddr, 4);
808 }
809 ip_tunnel_add(itn, t);
810
811 t->parms.iph.ttl = p->iph.ttl;
812 t->parms.iph.tos = p->iph.tos;
813 t->parms.iph.frag_off = p->iph.frag_off;
814
815 if (t->parms.link != p->link) {
816 int mtu;
817
818 t->parms.link = p->link;
819 mtu = ip_tunnel_bind_dev(dev);
820 if (set_mtu)
821 dev->mtu = mtu;
822 }
823 dst_cache_reset(&t->dst_cache);
824 netdev_state_change(dev);
825 }
826
827 int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
828 {
829 int err = 0;
830 struct ip_tunnel *t = netdev_priv(dev);
831 struct net *net = t->net;
832 struct ip_tunnel_net *itn = net_generic(net, t->ip_tnl_net_id);
833
834 BUG_ON(!itn->fb_tunnel_dev);
835 switch (cmd) {
836 case SIOCGETTUNNEL:
837 if (dev == itn->fb_tunnel_dev) {
838 t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
839 if (!t)
840 t = netdev_priv(dev);
841 }
842 memcpy(p, &t->parms, sizeof(*p));
843 break;
844
845 case SIOCADDTUNNEL:
846 case SIOCCHGTUNNEL:
847 err = -EPERM;
848 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
849 goto done;
850 if (p->iph.ttl)
851 p->iph.frag_off |= htons(IP_DF);
852 if (!(p->i_flags & VTI_ISVTI)) {
853 if (!(p->i_flags & TUNNEL_KEY))
854 p->i_key = 0;
855 if (!(p->o_flags & TUNNEL_KEY))
856 p->o_key = 0;
857 }
858
859 t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
860
861 if (cmd == SIOCADDTUNNEL) {
862 if (!t) {
863 t = ip_tunnel_create(net, itn, p);
864 err = PTR_ERR_OR_ZERO(t);
865 break;
866 }
867
868 err = -EEXIST;
869 break;
870 }
871 if (dev != itn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
872 if (t) {
873 if (t->dev != dev) {
874 err = -EEXIST;
875 break;
876 }
877 } else {
878 unsigned int nflags = 0;
879
880 if (ipv4_is_multicast(p->iph.daddr))
881 nflags = IFF_BROADCAST;
882 else if (p->iph.daddr)
883 nflags = IFF_POINTOPOINT;
884
885 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
886 err = -EINVAL;
887 break;
888 }
889
890 t = netdev_priv(dev);
891 }
892 }
893
894 if (t) {
895 err = 0;
896 ip_tunnel_update(itn, t, dev, p, true);
897 } else {
898 err = -ENOENT;
899 }
900 break;
901
902 case SIOCDELTUNNEL:
903 err = -EPERM;
904 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
905 goto done;
906
907 if (dev == itn->fb_tunnel_dev) {
908 err = -ENOENT;
909 t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
910 if (!t)
911 goto done;
912 err = -EPERM;
913 if (t == netdev_priv(itn->fb_tunnel_dev))
914 goto done;
915 dev = t->dev;
916 }
917 unregister_netdevice(dev);
918 err = 0;
919 break;
920
921 default:
922 err = -EINVAL;
923 }
924
925 done:
926 return err;
927 }
928 EXPORT_SYMBOL_GPL(ip_tunnel_ioctl);
929
930 int __ip_tunnel_change_mtu(struct net_device *dev, int new_mtu, bool strict)
931 {
932 struct ip_tunnel *tunnel = netdev_priv(dev);
933 int t_hlen = tunnel->hlen + sizeof(struct iphdr);
934 int max_mtu = 0xFFF8 - dev->hard_header_len - t_hlen;
935
936 if (new_mtu < ETH_MIN_MTU)
937 return -EINVAL;
938
939 if (new_mtu > max_mtu) {
940 if (strict)
941 return -EINVAL;
942
943 new_mtu = max_mtu;
944 }
945
946 dev->mtu = new_mtu;
947 return 0;
948 }
949 EXPORT_SYMBOL_GPL(__ip_tunnel_change_mtu);
950
951 int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
952 {
953 return __ip_tunnel_change_mtu(dev, new_mtu, true);
954 }
955 EXPORT_SYMBOL_GPL(ip_tunnel_change_mtu);
956
957 static void ip_tunnel_dev_free(struct net_device *dev)
958 {
959 struct ip_tunnel *tunnel = netdev_priv(dev);
960
961 gro_cells_destroy(&tunnel->gro_cells);
962 dst_cache_destroy(&tunnel->dst_cache);
963 free_percpu(dev->tstats);
964 free_netdev(dev);
965 }
966
967 void ip_tunnel_dellink(struct net_device *dev, struct list_head *head)
968 {
969 struct ip_tunnel *tunnel = netdev_priv(dev);
970 struct ip_tunnel_net *itn;
971
972 itn = net_generic(tunnel->net, tunnel->ip_tnl_net_id);
973
974 if (itn->fb_tunnel_dev != dev) {
975 ip_tunnel_del(itn, netdev_priv(dev));
976 unregister_netdevice_queue(dev, head);
977 }
978 }
979 EXPORT_SYMBOL_GPL(ip_tunnel_dellink);
980
981 struct net *ip_tunnel_get_link_net(const struct net_device *dev)
982 {
983 struct ip_tunnel *tunnel = netdev_priv(dev);
984
985 return tunnel->net;
986 }
987 EXPORT_SYMBOL(ip_tunnel_get_link_net);
988
989 int ip_tunnel_get_iflink(const struct net_device *dev)
990 {
991 struct ip_tunnel *tunnel = netdev_priv(dev);
992
993 return tunnel->parms.link;
994 }
995 EXPORT_SYMBOL(ip_tunnel_get_iflink);
996
997 int ip_tunnel_init_net(struct net *net, unsigned int ip_tnl_net_id,
998 struct rtnl_link_ops *ops, char *devname)
999 {
1000 struct ip_tunnel_net *itn = net_generic(net, ip_tnl_net_id);
1001 struct ip_tunnel_parm parms;
1002 unsigned int i;
1003
1004 for (i = 0; i < IP_TNL_HASH_SIZE; i++)
1005 INIT_HLIST_HEAD(&itn->tunnels[i]);
1006
1007 if (!ops) {
1008 itn->fb_tunnel_dev = NULL;
1009 return 0;
1010 }
1011
1012 memset(&parms, 0, sizeof(parms));
1013 if (devname)
1014 strlcpy(parms.name, devname, IFNAMSIZ);
1015
1016 rtnl_lock();
1017 itn->fb_tunnel_dev = __ip_tunnel_create(net, ops, &parms);
1018 /* FB netdevice is special: we have one, and only one per netns.
1019 * Allowing to move it to another netns is clearly unsafe.
1020 */
1021 if (!IS_ERR(itn->fb_tunnel_dev)) {
1022 itn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1023 itn->fb_tunnel_dev->mtu = ip_tunnel_bind_dev(itn->fb_tunnel_dev);
1024 ip_tunnel_add(itn, netdev_priv(itn->fb_tunnel_dev));
1025 }
1026 rtnl_unlock();
1027
1028 return PTR_ERR_OR_ZERO(itn->fb_tunnel_dev);
1029 }
1030 EXPORT_SYMBOL_GPL(ip_tunnel_init_net);
1031
1032 static void ip_tunnel_destroy(struct ip_tunnel_net *itn, struct list_head *head,
1033 struct rtnl_link_ops *ops)
1034 {
1035 struct net *net = dev_net(itn->fb_tunnel_dev);
1036 struct net_device *dev, *aux;
1037 int h;
1038
1039 for_each_netdev_safe(net, dev, aux)
1040 if (dev->rtnl_link_ops == ops)
1041 unregister_netdevice_queue(dev, head);
1042
1043 for (h = 0; h < IP_TNL_HASH_SIZE; h++) {
1044 struct ip_tunnel *t;
1045 struct hlist_node *n;
1046 struct hlist_head *thead = &itn->tunnels[h];
1047
1048 hlist_for_each_entry_safe(t, n, thead, hash_node)
1049 /* If dev is in the same netns, it has already
1050 * been added to the list by the previous loop.
1051 */
1052 if (!net_eq(dev_net(t->dev), net))
1053 unregister_netdevice_queue(t->dev, head);
1054 }
1055 }
1056
1057 void ip_tunnel_delete_net(struct ip_tunnel_net *itn, struct rtnl_link_ops *ops)
1058 {
1059 LIST_HEAD(list);
1060
1061 rtnl_lock();
1062 ip_tunnel_destroy(itn, &list, ops);
1063 unregister_netdevice_many(&list);
1064 rtnl_unlock();
1065 }
1066 EXPORT_SYMBOL_GPL(ip_tunnel_delete_net);
1067
1068 int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
1069 struct ip_tunnel_parm *p)
1070 {
1071 struct ip_tunnel *nt;
1072 struct net *net = dev_net(dev);
1073 struct ip_tunnel_net *itn;
1074 int mtu;
1075 int err;
1076
1077 nt = netdev_priv(dev);
1078 itn = net_generic(net, nt->ip_tnl_net_id);
1079
1080 if (nt->collect_md) {
1081 if (rtnl_dereference(itn->collect_md_tun))
1082 return -EEXIST;
1083 } else {
1084 if (ip_tunnel_find(itn, p, dev->type))
1085 return -EEXIST;
1086 }
1087
1088 nt->net = net;
1089 nt->parms = *p;
1090 err = register_netdevice(dev);
1091 if (err)
1092 goto out;
1093
1094 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
1095 eth_hw_addr_random(dev);
1096
1097 mtu = ip_tunnel_bind_dev(dev);
1098 if (!tb[IFLA_MTU])
1099 dev->mtu = mtu;
1100
1101 ip_tunnel_add(itn, nt);
1102 out:
1103 return err;
1104 }
1105 EXPORT_SYMBOL_GPL(ip_tunnel_newlink);
1106
1107 int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
1108 struct ip_tunnel_parm *p)
1109 {
1110 struct ip_tunnel *t;
1111 struct ip_tunnel *tunnel = netdev_priv(dev);
1112 struct net *net = tunnel->net;
1113 struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
1114
1115 if (dev == itn->fb_tunnel_dev)
1116 return -EINVAL;
1117
1118 t = ip_tunnel_find(itn, p, dev->type);
1119
1120 if (t) {
1121 if (t->dev != dev)
1122 return -EEXIST;
1123 } else {
1124 t = tunnel;
1125
1126 if (dev->type != ARPHRD_ETHER) {
1127 unsigned int nflags = 0;
1128
1129 if (ipv4_is_multicast(p->iph.daddr))
1130 nflags = IFF_BROADCAST;
1131 else if (p->iph.daddr)
1132 nflags = IFF_POINTOPOINT;
1133
1134 if ((dev->flags ^ nflags) &
1135 (IFF_POINTOPOINT | IFF_BROADCAST))
1136 return -EINVAL;
1137 }
1138 }
1139
1140 ip_tunnel_update(itn, t, dev, p, !tb[IFLA_MTU]);
1141 return 0;
1142 }
1143 EXPORT_SYMBOL_GPL(ip_tunnel_changelink);
1144
1145 int ip_tunnel_init(struct net_device *dev)
1146 {
1147 struct ip_tunnel *tunnel = netdev_priv(dev);
1148 struct iphdr *iph = &tunnel->parms.iph;
1149 int err;
1150
1151 dev->destructor = ip_tunnel_dev_free;
1152 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1153 if (!dev->tstats)
1154 return -ENOMEM;
1155
1156 err = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
1157 if (err) {
1158 free_percpu(dev->tstats);
1159 return err;
1160 }
1161
1162 err = gro_cells_init(&tunnel->gro_cells, dev);
1163 if (err) {
1164 dst_cache_destroy(&tunnel->dst_cache);
1165 free_percpu(dev->tstats);
1166 return err;
1167 }
1168
1169 tunnel->dev = dev;
1170 tunnel->net = dev_net(dev);
1171 strcpy(tunnel->parms.name, dev->name);
1172 iph->version = 4;
1173 iph->ihl = 5;
1174
1175 if (tunnel->collect_md) {
1176 dev->features |= NETIF_F_NETNS_LOCAL;
1177 netif_keep_dst(dev);
1178 }
1179 return 0;
1180 }
1181 EXPORT_SYMBOL_GPL(ip_tunnel_init);
1182
1183 void ip_tunnel_uninit(struct net_device *dev)
1184 {
1185 struct ip_tunnel *tunnel = netdev_priv(dev);
1186 struct net *net = tunnel->net;
1187 struct ip_tunnel_net *itn;
1188
1189 itn = net_generic(net, tunnel->ip_tnl_net_id);
1190 /* fb_tunnel_dev will be unregisted in net-exit call. */
1191 if (itn->fb_tunnel_dev != dev)
1192 ip_tunnel_del(itn, netdev_priv(dev));
1193
1194 dst_cache_reset(&tunnel->dst_cache);
1195 }
1196 EXPORT_SYMBOL_GPL(ip_tunnel_uninit);
1197
1198 /* Do least required initialization, rest of init is done in tunnel_init call */
1199 void ip_tunnel_setup(struct net_device *dev, unsigned int net_id)
1200 {
1201 struct ip_tunnel *tunnel = netdev_priv(dev);
1202 tunnel->ip_tnl_net_id = net_id;
1203 }
1204 EXPORT_SYMBOL_GPL(ip_tunnel_setup);
1205
1206 MODULE_LICENSE("GPL");
Linux with added FPC-III support