1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23#include <linux/module.h>
24#include <linux/capability.h>
25#include <linux/errno.h>
26#include <linux/types.h>
27#include <linux/sockios.h>
28#include <linux/icmp.h>
29#include <linux/if.h>
30#include <linux/in.h>
31#include <linux/ip.h>
32#include <linux/if_tunnel.h>
33#include <linux/net.h>
34#include <linux/in6.h>
35#include <linux/netdevice.h>
36#include <linux/if_arp.h>
37#include <linux/icmpv6.h>
38#include <linux/init.h>
39#include <linux/route.h>
40#include <linux/rtnetlink.h>
41#include <linux/netfilter_ipv6.h>
42#include <linux/slab.h>
43#include <linux/hash.h>
44
45#include <asm/uaccess.h>
46#include <linux/atomic.h>
47
48#include <net/icmp.h>
49#include <net/ip.h>
50#include <net/ip_tunnels.h>
51#include <net/ipv6.h>
52#include <net/ip6_route.h>
53#include <net/addrconf.h>
54#include <net/ip6_tunnel.h>
55#include <net/xfrm.h>
56#include <net/dsfield.h>
57#include <net/inet_ecn.h>
58#include <net/net_namespace.h>
59#include <net/netns/generic.h>
60
61MODULE_AUTHOR("Ville Nuorvala");
62MODULE_DESCRIPTION("IPv6 tunneling device");
63MODULE_LICENSE("GPL");
64MODULE_ALIAS_NETDEV("ip6tnl0");
65
66#ifdef IP6_TNL_DEBUG
67#define IP6_TNL_TRACE(x...) pr_debug("%s:" x "\n", __func__)
68#else
69#define IP6_TNL_TRACE(x...) do {;} while(0)
70#endif
71
72#define IPV6_TCLASS_MASK (IPV6_FLOWINFO_MASK & ~IPV6_FLOWLABEL_MASK)
73#define IPV6_TCLASS_SHIFT 20
74
75#define HASH_SIZE_SHIFT 5
76#define HASH_SIZE (1 << HASH_SIZE_SHIFT)
77
78static bool log_ecn_error = true;
79module_param(log_ecn_error, bool, 0644);
80MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
81
82static u32 HASH(const struct in6_addr *addr1, const struct in6_addr *addr2)
83{
84 u32 hash = ipv6_addr_hash(addr1) ^ ipv6_addr_hash(addr2);
85
86 return hash_32(hash, HASH_SIZE_SHIFT);
87}
88
89static int ip6_tnl_dev_init(struct net_device *dev);
90static void ip6_tnl_dev_setup(struct net_device *dev);
91static struct rtnl_link_ops ip6_link_ops __read_mostly;
92
93static int ip6_tnl_net_id __read_mostly;
94struct ip6_tnl_net {
95
96 struct net_device *fb_tnl_dev;
97
98 struct ip6_tnl __rcu *tnls_r_l[HASH_SIZE];
99 struct ip6_tnl __rcu *tnls_wc[1];
100 struct ip6_tnl __rcu **tnls[2];
101};
102
103static struct net_device_stats *ip6_get_stats(struct net_device *dev)
104{
105 struct pcpu_tstats sum = { 0 };
106 int i;
107
108 for_each_possible_cpu(i) {
109 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
110
111 sum.rx_packets += tstats->rx_packets;
112 sum.rx_bytes += tstats->rx_bytes;
113 sum.tx_packets += tstats->tx_packets;
114 sum.tx_bytes += tstats->tx_bytes;
115 }
116 dev->stats.rx_packets = sum.rx_packets;
117 dev->stats.rx_bytes = sum.rx_bytes;
118 dev->stats.tx_packets = sum.tx_packets;
119 dev->stats.tx_bytes = sum.tx_bytes;
120 return &dev->stats;
121}
122
123
124
125
126
127struct dst_entry *ip6_tnl_dst_check(struct ip6_tnl *t)
128{
129 struct dst_entry *dst = t->dst_cache;
130
131 if (dst && dst->obsolete &&
132 dst->ops->check(dst, t->dst_cookie) == NULL) {
133 t->dst_cache = NULL;
134 dst_release(dst);
135 return NULL;
136 }
137
138 return dst;
139}
140EXPORT_SYMBOL_GPL(ip6_tnl_dst_check);
141
142void ip6_tnl_dst_reset(struct ip6_tnl *t)
143{
144 dst_release(t->dst_cache);
145 t->dst_cache = NULL;
146}
147EXPORT_SYMBOL_GPL(ip6_tnl_dst_reset);
148
149void ip6_tnl_dst_store(struct ip6_tnl *t, struct dst_entry *dst)
150{
151 struct rt6_info *rt = (struct rt6_info *) dst;
152 t->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0;
153 dst_release(t->dst_cache);
154 t->dst_cache = dst;
155}
156EXPORT_SYMBOL_GPL(ip6_tnl_dst_store);
157
158
159
160
161
162
163
164
165
166
167
168
169#define for_each_ip6_tunnel_rcu(start) \
170 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
171
172static struct ip6_tnl *
173ip6_tnl_lookup(struct net *net, const struct in6_addr *remote, const struct in6_addr *local)
174{
175 unsigned int hash = HASH(remote, local);
176 struct ip6_tnl *t;
177 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
178
179 for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
180 if (ipv6_addr_equal(local, &t->parms.laddr) &&
181 ipv6_addr_equal(remote, &t->parms.raddr) &&
182 (t->dev->flags & IFF_UP))
183 return t;
184 }
185 t = rcu_dereference(ip6n->tnls_wc[0]);
186 if (t && (t->dev->flags & IFF_UP))
187 return t;
188
189 return NULL;
190}
191
192
193
194
195
196
197
198
199
200
201
202
203static struct ip6_tnl __rcu **
204ip6_tnl_bucket(struct ip6_tnl_net *ip6n, const struct __ip6_tnl_parm *p)
205{
206 const struct in6_addr *remote = &p->raddr;
207 const struct in6_addr *local = &p->laddr;
208 unsigned int h = 0;
209 int prio = 0;
210
211 if (!ipv6_addr_any(remote) || !ipv6_addr_any(local)) {
212 prio = 1;
213 h = HASH(remote, local);
214 }
215 return &ip6n->tnls[prio][h];
216}
217
218
219
220
221
222
223static void
224ip6_tnl_link(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
225{
226 struct ip6_tnl __rcu **tp = ip6_tnl_bucket(ip6n, &t->parms);
227
228 rcu_assign_pointer(t->next , rtnl_dereference(*tp));
229 rcu_assign_pointer(*tp, t);
230}
231
232
233
234
235
236
237static void
238ip6_tnl_unlink(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
239{
240 struct ip6_tnl __rcu **tp;
241 struct ip6_tnl *iter;
242
243 for (tp = ip6_tnl_bucket(ip6n, &t->parms);
244 (iter = rtnl_dereference(*tp)) != NULL;
245 tp = &iter->next) {
246 if (t == iter) {
247 rcu_assign_pointer(*tp, t->next);
248 break;
249 }
250 }
251}
252
253static void ip6_dev_free(struct net_device *dev)
254{
255 free_percpu(dev->tstats);
256 free_netdev(dev);
257}
258
259static int ip6_tnl_create2(struct net_device *dev)
260{
261 struct ip6_tnl *t = netdev_priv(dev);
262 struct net *net = dev_net(dev);
263 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
264 int err;
265
266 t = netdev_priv(dev);
267 err = ip6_tnl_dev_init(dev);
268 if (err < 0)
269 goto out;
270
271 err = register_netdevice(dev);
272 if (err < 0)
273 goto out;
274
275 strcpy(t->parms.name, dev->name);
276 dev->rtnl_link_ops = &ip6_link_ops;
277
278 dev_hold(dev);
279 ip6_tnl_link(ip6n, t);
280 return 0;
281
282out:
283 return err;
284}
285
286
287
288
289
290
291
292
293
294
295
296
297
298static struct ip6_tnl *ip6_tnl_create(struct net *net, struct __ip6_tnl_parm *p)
299{
300 struct net_device *dev;
301 struct ip6_tnl *t;
302 char name[IFNAMSIZ];
303 int err;
304
305 if (p->name[0])
306 strlcpy(name, p->name, IFNAMSIZ);
307 else
308 sprintf(name, "ip6tnl%%d");
309
310 dev = alloc_netdev(sizeof (*t), name, ip6_tnl_dev_setup);
311 if (dev == NULL)
312 goto failed;
313
314 dev_net_set(dev, net);
315
316 t = netdev_priv(dev);
317 t->parms = *p;
318 err = ip6_tnl_create2(dev);
319 if (err < 0)
320 goto failed_free;
321
322 return t;
323
324failed_free:
325 ip6_dev_free(dev);
326failed:
327 return NULL;
328}
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344static struct ip6_tnl *ip6_tnl_locate(struct net *net,
345 struct __ip6_tnl_parm *p, int create)
346{
347 const struct in6_addr *remote = &p->raddr;
348 const struct in6_addr *local = &p->laddr;
349 struct ip6_tnl __rcu **tp;
350 struct ip6_tnl *t;
351 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
352
353 for (tp = ip6_tnl_bucket(ip6n, p);
354 (t = rtnl_dereference(*tp)) != NULL;
355 tp = &t->next) {
356 if (ipv6_addr_equal(local, &t->parms.laddr) &&
357 ipv6_addr_equal(remote, &t->parms.raddr))
358 return t;
359 }
360 if (!create)
361 return NULL;
362 return ip6_tnl_create(net, p);
363}
364
365
366
367
368
369
370
371
372
373static void
374ip6_tnl_dev_uninit(struct net_device *dev)
375{
376 struct ip6_tnl *t = netdev_priv(dev);
377 struct net *net = dev_net(dev);
378 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
379
380 if (dev == ip6n->fb_tnl_dev)
381 RCU_INIT_POINTER(ip6n->tnls_wc[0], NULL);
382 else
383 ip6_tnl_unlink(ip6n, t);
384 ip6_tnl_dst_reset(t);
385 dev_put(dev);
386}
387
388
389
390
391
392
393
394
395
396
397__u16 ip6_tnl_parse_tlv_enc_lim(struct sk_buff *skb, __u8 *raw)
398{
399 const struct ipv6hdr *ipv6h = (const struct ipv6hdr *) raw;
400 __u8 nexthdr = ipv6h->nexthdr;
401 __u16 off = sizeof (*ipv6h);
402
403 while (ipv6_ext_hdr(nexthdr) && nexthdr != NEXTHDR_NONE) {
404 __u16 optlen = 0;
405 struct ipv6_opt_hdr *hdr;
406 if (raw + off + sizeof (*hdr) > skb->data &&
407 !pskb_may_pull(skb, raw - skb->data + off + sizeof (*hdr)))
408 break;
409
410 hdr = (struct ipv6_opt_hdr *) (raw + off);
411 if (nexthdr == NEXTHDR_FRAGMENT) {
412 struct frag_hdr *frag_hdr = (struct frag_hdr *) hdr;
413 if (frag_hdr->frag_off)
414 break;
415 optlen = 8;
416 } else if (nexthdr == NEXTHDR_AUTH) {
417 optlen = (hdr->hdrlen + 2) << 2;
418 } else {
419 optlen = ipv6_optlen(hdr);
420 }
421 if (nexthdr == NEXTHDR_DEST) {
422 __u16 i = off + 2;
423 while (1) {
424 struct ipv6_tlv_tnl_enc_lim *tel;
425
426
427 if (i + sizeof (*tel) > off + optlen)
428 break;
429
430 tel = (struct ipv6_tlv_tnl_enc_lim *) &raw[i];
431
432 if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
433 tel->length == 1)
434 return i;
435
436 if (tel->type)
437 i += tel->length + 2;
438 else
439 i++;
440 }
441 }
442 nexthdr = hdr->nexthdr;
443 off += optlen;
444 }
445 return 0;
446}
447EXPORT_SYMBOL(ip6_tnl_parse_tlv_enc_lim);
448
449
450
451
452
453
454
455
456
457static int
458ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
459 u8 *type, u8 *code, int *msg, __u32 *info, int offset)
460{
461 const struct ipv6hdr *ipv6h = (const struct ipv6hdr *) skb->data;
462 struct ip6_tnl *t;
463 int rel_msg = 0;
464 u8 rel_type = ICMPV6_DEST_UNREACH;
465 u8 rel_code = ICMPV6_ADDR_UNREACH;
466 __u32 rel_info = 0;
467 __u16 len;
468 int err = -ENOENT;
469
470
471
472
473
474 rcu_read_lock();
475 if ((t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->daddr,
476 &ipv6h->saddr)) == NULL)
477 goto out;
478
479 if (t->parms.proto != ipproto && t->parms.proto != 0)
480 goto out;
481
482 err = 0;
483
484 switch (*type) {
485 __u32 teli;
486 struct ipv6_tlv_tnl_enc_lim *tel;
487 __u32 mtu;
488 case ICMPV6_DEST_UNREACH:
489 net_warn_ratelimited("%s: Path to destination invalid or inactive!\n",
490 t->parms.name);
491 rel_msg = 1;
492 break;
493 case ICMPV6_TIME_EXCEED:
494 if ((*code) == ICMPV6_EXC_HOPLIMIT) {
495 net_warn_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
496 t->parms.name);
497 rel_msg = 1;
498 }
499 break;
500 case ICMPV6_PARAMPROB:
501 teli = 0;
502 if ((*code) == ICMPV6_HDR_FIELD)
503 teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
504
505 if (teli && teli == *info - 2) {
506 tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
507 if (tel->encap_limit == 0) {
508 net_warn_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
509 t->parms.name);
510 rel_msg = 1;
511 }
512 } else {
513 net_warn_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
514 t->parms.name);
515 }
516 break;
517 case ICMPV6_PKT_TOOBIG:
518 mtu = *info - offset;
519 if (mtu < IPV6_MIN_MTU)
520 mtu = IPV6_MIN_MTU;
521 t->dev->mtu = mtu;
522
523 if ((len = sizeof (*ipv6h) + ntohs(ipv6h->payload_len)) > mtu) {
524 rel_type = ICMPV6_PKT_TOOBIG;
525 rel_code = 0;
526 rel_info = mtu;
527 rel_msg = 1;
528 }
529 break;
530 }
531
532 *type = rel_type;
533 *code = rel_code;
534 *info = rel_info;
535 *msg = rel_msg;
536
537out:
538 rcu_read_unlock();
539 return err;
540}
541
542static int
543ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
544 u8 type, u8 code, int offset, __be32 info)
545{
546 int rel_msg = 0;
547 u8 rel_type = type;
548 u8 rel_code = code;
549 __u32 rel_info = ntohl(info);
550 int err;
551 struct sk_buff *skb2;
552 const struct iphdr *eiph;
553 struct rtable *rt;
554 struct flowi4 fl4;
555
556 err = ip6_tnl_err(skb, IPPROTO_IPIP, opt, &rel_type, &rel_code,
557 &rel_msg, &rel_info, offset);
558 if (err < 0)
559 return err;
560
561 if (rel_msg == 0)
562 return 0;
563
564 switch (rel_type) {
565 case ICMPV6_DEST_UNREACH:
566 if (rel_code != ICMPV6_ADDR_UNREACH)
567 return 0;
568 rel_type = ICMP_DEST_UNREACH;
569 rel_code = ICMP_HOST_UNREACH;
570 break;
571 case ICMPV6_PKT_TOOBIG:
572 if (rel_code != 0)
573 return 0;
574 rel_type = ICMP_DEST_UNREACH;
575 rel_code = ICMP_FRAG_NEEDED;
576 break;
577 case NDISC_REDIRECT:
578 rel_type = ICMP_REDIRECT;
579 rel_code = ICMP_REDIR_HOST;
580 default:
581 return 0;
582 }
583
584 if (!pskb_may_pull(skb, offset + sizeof(struct iphdr)))
585 return 0;
586
587 skb2 = skb_clone(skb, GFP_ATOMIC);
588 if (!skb2)
589 return 0;
590
591 skb_dst_drop(skb2);
592
593 skb_pull(skb2, offset);
594 skb_reset_network_header(skb2);
595 eiph = ip_hdr(skb2);
596
597
598 rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
599 eiph->saddr, 0,
600 0, 0,
601 IPPROTO_IPIP, RT_TOS(eiph->tos), 0);
602 if (IS_ERR(rt))
603 goto out;
604
605 skb2->dev = rt->dst.dev;
606
607
608 if (rt->rt_flags & RTCF_LOCAL) {
609 ip_rt_put(rt);
610 rt = NULL;
611 rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
612 eiph->daddr, eiph->saddr,
613 0, 0,
614 IPPROTO_IPIP,
615 RT_TOS(eiph->tos), 0);
616 if (IS_ERR(rt) ||
617 rt->dst.dev->type != ARPHRD_TUNNEL) {
618 if (!IS_ERR(rt))
619 ip_rt_put(rt);
620 goto out;
621 }
622 skb_dst_set(skb2, &rt->dst);
623 } else {
624 ip_rt_put(rt);
625 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos,
626 skb2->dev) ||
627 skb_dst(skb2)->dev->type != ARPHRD_TUNNEL)
628 goto out;
629 }
630
631
632 if (rel_type == ICMP_DEST_UNREACH && rel_code == ICMP_FRAG_NEEDED) {
633 if (rel_info > dst_mtu(skb_dst(skb2)))
634 goto out;
635
636 skb_dst(skb2)->ops->update_pmtu(skb_dst(skb2), NULL, skb2, rel_info);
637 }
638 if (rel_type == ICMP_REDIRECT)
639 skb_dst(skb2)->ops->redirect(skb_dst(skb2), NULL, skb2);
640
641 icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
642
643out:
644 kfree_skb(skb2);
645 return 0;
646}
647
648static int
649ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
650 u8 type, u8 code, int offset, __be32 info)
651{
652 int rel_msg = 0;
653 u8 rel_type = type;
654 u8 rel_code = code;
655 __u32 rel_info = ntohl(info);
656 int err;
657
658 err = ip6_tnl_err(skb, IPPROTO_IPV6, opt, &rel_type, &rel_code,
659 &rel_msg, &rel_info, offset);
660 if (err < 0)
661 return err;
662
663 if (rel_msg && pskb_may_pull(skb, offset + sizeof(struct ipv6hdr))) {
664 struct rt6_info *rt;
665 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
666
667 if (!skb2)
668 return 0;
669
670 skb_dst_drop(skb2);
671 skb_pull(skb2, offset);
672 skb_reset_network_header(skb2);
673
674
675 rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr,
676 NULL, 0, 0);
677
678 if (rt && rt->dst.dev)
679 skb2->dev = rt->dst.dev;
680
681 icmpv6_send(skb2, rel_type, rel_code, rel_info);
682
683 ip6_rt_put(rt);
684
685 kfree_skb(skb2);
686 }
687
688 return 0;
689}
690
691static int ip4ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
692 const struct ipv6hdr *ipv6h,
693 struct sk_buff *skb)
694{
695 __u8 dsfield = ipv6_get_dsfield(ipv6h) & ~INET_ECN_MASK;
696
697 if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
698 ipv4_change_dsfield(ip_hdr(skb), INET_ECN_MASK, dsfield);
699
700 return IP6_ECN_decapsulate(ipv6h, skb);
701}
702
703static int ip6ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
704 const struct ipv6hdr *ipv6h,
705 struct sk_buff *skb)
706{
707 if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
708 ipv6_copy_dscp(ipv6_get_dsfield(ipv6h), ipv6_hdr(skb));
709
710 return IP6_ECN_decapsulate(ipv6h, skb);
711}
712
713__u32 ip6_tnl_get_cap(struct ip6_tnl *t,
714 const struct in6_addr *laddr,
715 const struct in6_addr *raddr)
716{
717 struct __ip6_tnl_parm *p = &t->parms;
718 int ltype = ipv6_addr_type(laddr);
719 int rtype = ipv6_addr_type(raddr);
720 __u32 flags = 0;
721
722 if (ltype == IPV6_ADDR_ANY || rtype == IPV6_ADDR_ANY) {
723 flags = IP6_TNL_F_CAP_PER_PACKET;
724 } else if (ltype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
725 rtype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
726 !((ltype|rtype) & IPV6_ADDR_LOOPBACK) &&
727 (!((ltype|rtype) & IPV6_ADDR_LINKLOCAL) || p->link)) {
728 if (ltype&IPV6_ADDR_UNICAST)
729 flags |= IP6_TNL_F_CAP_XMIT;
730 if (rtype&IPV6_ADDR_UNICAST)
731 flags |= IP6_TNL_F_CAP_RCV;
732 }
733 return flags;
734}
735EXPORT_SYMBOL(ip6_tnl_get_cap);
736
737
738int ip6_tnl_rcv_ctl(struct ip6_tnl *t,
739 const struct in6_addr *laddr,
740 const struct in6_addr *raddr)
741{
742 struct __ip6_tnl_parm *p = &t->parms;
743 int ret = 0;
744 struct net *net = dev_net(t->dev);
745
746 if ((p->flags & IP6_TNL_F_CAP_RCV) ||
747 ((p->flags & IP6_TNL_F_CAP_PER_PACKET) &&
748 (ip6_tnl_get_cap(t, laddr, raddr) & IP6_TNL_F_CAP_RCV))) {
749 struct net_device *ldev = NULL;
750
751 if (p->link)
752 ldev = dev_get_by_index_rcu(net, p->link);
753
754 if ((ipv6_addr_is_multicast(laddr) ||
755 likely(ipv6_chk_addr(net, laddr, ldev, 0))) &&
756 likely(!ipv6_chk_addr(net, raddr, NULL, 0)))
757 ret = 1;
758 }
759 return ret;
760}
761EXPORT_SYMBOL_GPL(ip6_tnl_rcv_ctl);
762
763
764
765
766
767
768
769
770
771
772static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,
773 __u8 ipproto,
774 int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
775 const struct ipv6hdr *ipv6h,
776 struct sk_buff *skb))
777{
778 struct ip6_tnl *t;
779 const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
780 int err;
781
782 rcu_read_lock();
783
784 if ((t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr,
785 &ipv6h->daddr)) != NULL) {
786 struct pcpu_tstats *tstats;
787
788 if (t->parms.proto != ipproto && t->parms.proto != 0) {
789 rcu_read_unlock();
790 goto discard;
791 }
792
793 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
794 rcu_read_unlock();
795 goto discard;
796 }
797
798 if (!ip6_tnl_rcv_ctl(t, &ipv6h->daddr, &ipv6h->saddr)) {
799 t->dev->stats.rx_dropped++;
800 rcu_read_unlock();
801 goto discard;
802 }
803 secpath_reset(skb);
804 skb->mac_header = skb->network_header;
805 skb_reset_network_header(skb);
806 skb->protocol = htons(protocol);
807 skb->pkt_type = PACKET_HOST;
808 memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
809
810 __skb_tunnel_rx(skb, t->dev);
811
812 err = dscp_ecn_decapsulate(t, ipv6h, skb);
813 if (unlikely(err)) {
814 if (log_ecn_error)
815 net_info_ratelimited("non-ECT from %pI6 with dsfield=%#x\n",
816 &ipv6h->saddr,
817 ipv6_get_dsfield(ipv6h));
818 if (err > 1) {
819 ++t->dev->stats.rx_frame_errors;
820 ++t->dev->stats.rx_errors;
821 rcu_read_unlock();
822 goto discard;
823 }
824 }
825
826 tstats = this_cpu_ptr(t->dev->tstats);
827 tstats->rx_packets++;
828 tstats->rx_bytes += skb->len;
829
830 netif_rx(skb);
831
832 rcu_read_unlock();
833 return 0;
834 }
835 rcu_read_unlock();
836 return 1;
837
838discard:
839 kfree_skb(skb);
840 return 0;
841}
842
843static int ip4ip6_rcv(struct sk_buff *skb)
844{
845 return ip6_tnl_rcv(skb, ETH_P_IP, IPPROTO_IPIP,
846 ip4ip6_dscp_ecn_decapsulate);
847}
848
849static int ip6ip6_rcv(struct sk_buff *skb)
850{
851 return ip6_tnl_rcv(skb, ETH_P_IPV6, IPPROTO_IPV6,
852 ip6ip6_dscp_ecn_decapsulate);
853}
854
855struct ipv6_tel_txoption {
856 struct ipv6_txoptions ops;
857 __u8 dst_opt[8];
858};
859
860static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)
861{
862 memset(opt, 0, sizeof(struct ipv6_tel_txoption));
863
864 opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;
865 opt->dst_opt[3] = 1;
866 opt->dst_opt[4] = encap_limit;
867 opt->dst_opt[5] = IPV6_TLV_PADN;
868 opt->dst_opt[6] = 1;
869
870 opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;
871 opt->ops.opt_nflen = 8;
872}
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888static inline bool
889ip6_tnl_addr_conflict(const struct ip6_tnl *t, const struct ipv6hdr *hdr)
890{
891 return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
892}
893
894int ip6_tnl_xmit_ctl(struct ip6_tnl *t)
895{
896 struct __ip6_tnl_parm *p = &t->parms;
897 int ret = 0;
898 struct net *net = dev_net(t->dev);
899
900 if (p->flags & IP6_TNL_F_CAP_XMIT) {
901 struct net_device *ldev = NULL;
902
903 rcu_read_lock();
904 if (p->link)
905 ldev = dev_get_by_index_rcu(net, p->link);
906
907 if (unlikely(!ipv6_chk_addr(net, &p->laddr, ldev, 0)))
908 pr_warn("%s xmit: Local address not yet configured!\n",
909 p->name);
910 else if (!ipv6_addr_is_multicast(&p->raddr) &&
911 unlikely(ipv6_chk_addr(net, &p->raddr, NULL, 0)))
912 pr_warn("%s xmit: Routing loop! Remote address found on this node!\n",
913 p->name);
914 else
915 ret = 1;
916 rcu_read_unlock();
917 }
918 return ret;
919}
920EXPORT_SYMBOL_GPL(ip6_tnl_xmit_ctl);
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941static int ip6_tnl_xmit2(struct sk_buff *skb,
942 struct net_device *dev,
943 __u8 dsfield,
944 struct flowi6 *fl6,
945 int encap_limit,
946 __u32 *pmtu)
947{
948 struct net *net = dev_net(dev);
949 struct ip6_tnl *t = netdev_priv(dev);
950 struct net_device_stats *stats = &t->dev->stats;
951 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
952 struct ipv6_tel_txoption opt;
953 struct dst_entry *dst = NULL, *ndst = NULL;
954 struct net_device *tdev;
955 int mtu;
956 unsigned int max_headroom = sizeof(struct ipv6hdr);
957 u8 proto;
958 int err = -1;
959
960 if (!fl6->flowi6_mark)
961 dst = ip6_tnl_dst_check(t);
962 if (!dst) {
963 ndst = ip6_route_output(net, NULL, fl6);
964
965 if (ndst->error)
966 goto tx_err_link_failure;
967 ndst = xfrm_lookup(net, ndst, flowi6_to_flowi(fl6), NULL, 0);
968 if (IS_ERR(ndst)) {
969 err = PTR_ERR(ndst);
970 ndst = NULL;
971 goto tx_err_link_failure;
972 }
973 dst = ndst;
974 }
975
976 tdev = dst->dev;
977
978 if (tdev == dev) {
979 stats->collisions++;
980 net_warn_ratelimited("%s: Local routing loop detected!\n",
981 t->parms.name);
982 goto tx_err_dst_release;
983 }
984 mtu = dst_mtu(dst) - sizeof (*ipv6h);
985 if (encap_limit >= 0) {
986 max_headroom += 8;
987 mtu -= 8;
988 }
989 if (mtu < IPV6_MIN_MTU)
990 mtu = IPV6_MIN_MTU;
991 if (skb_dst(skb))
992 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
993 if (skb->len > mtu) {
994 *pmtu = mtu;
995 err = -EMSGSIZE;
996 goto tx_err_dst_release;
997 }
998
999
1000
1001
1002 max_headroom += LL_RESERVED_SPACE(tdev);
1003
1004 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
1005 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
1006 struct sk_buff *new_skb;
1007
1008 if (!(new_skb = skb_realloc_headroom(skb, max_headroom)))
1009 goto tx_err_dst_release;
1010
1011 if (skb->sk)
1012 skb_set_owner_w(new_skb, skb->sk);
1013 consume_skb(skb);
1014 skb = new_skb;
1015 }
1016 skb_dst_drop(skb);
1017 if (fl6->flowi6_mark) {
1018 skb_dst_set(skb, dst);
1019 ndst = NULL;
1020 } else {
1021 skb_dst_set_noref(skb, dst);
1022 }
1023 skb->transport_header = skb->network_header;
1024
1025 proto = fl6->flowi6_proto;
1026 if (encap_limit >= 0) {
1027 init_tel_txopt(&opt, encap_limit);
1028 ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);
1029 }
1030 skb_push(skb, sizeof(struct ipv6hdr));
1031 skb_reset_network_header(skb);
1032 ipv6h = ipv6_hdr(skb);
1033 ip6_flow_hdr(ipv6h, INET_ECN_encapsulate(0, dsfield), fl6->flowlabel);
1034 ipv6h->hop_limit = t->parms.hop_limit;
1035 ipv6h->nexthdr = proto;
1036 ipv6h->saddr = fl6->saddr;
1037 ipv6h->daddr = fl6->daddr;
1038 ip6tunnel_xmit(skb, dev);
1039 if (ndst)
1040 ip6_tnl_dst_store(t, ndst);
1041 return 0;
1042tx_err_link_failure:
1043 stats->tx_carrier_errors++;
1044 dst_link_failure(skb);
1045tx_err_dst_release:
1046 dst_release(ndst);
1047 return err;
1048}
1049
1050static inline int
1051ip4ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1052{
1053 struct ip6_tnl *t = netdev_priv(dev);
1054 const struct iphdr *iph = ip_hdr(skb);
1055 int encap_limit = -1;
1056 struct flowi6 fl6;
1057 __u8 dsfield;
1058 __u32 mtu;
1059 int err;
1060
1061 if ((t->parms.proto != IPPROTO_IPIP && t->parms.proto != 0) ||
1062 !ip6_tnl_xmit_ctl(t))
1063 return -1;
1064
1065 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1066 encap_limit = t->parms.encap_limit;
1067
1068 memcpy(&fl6, &t->fl.u.ip6, sizeof (fl6));
1069 fl6.flowi6_proto = IPPROTO_IPIP;
1070
1071 dsfield = ipv4_get_dsfield(iph);
1072
1073 if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1074 fl6.flowlabel |= htonl((__u32)iph->tos << IPV6_TCLASS_SHIFT)
1075 & IPV6_TCLASS_MASK;
1076 if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
1077 fl6.flowi6_mark = skb->mark;
1078
1079 err = ip6_tnl_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);
1080 if (err != 0) {
1081
1082 if (err == -EMSGSIZE)
1083 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
1084 htonl(mtu));
1085 return -1;
1086 }
1087
1088 return 0;
1089}
1090
1091static inline int
1092ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1093{
1094 struct ip6_tnl *t = netdev_priv(dev);
1095 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
1096 int encap_limit = -1;
1097 __u16 offset;
1098 struct flowi6 fl6;
1099 __u8 dsfield;
1100 __u32 mtu;
1101 int err;
1102
1103 if ((t->parms.proto != IPPROTO_IPV6 && t->parms.proto != 0) ||
1104 !ip6_tnl_xmit_ctl(t) || ip6_tnl_addr_conflict(t, ipv6h))
1105 return -1;
1106
1107 offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));
1108 if (offset > 0) {
1109 struct ipv6_tlv_tnl_enc_lim *tel;
1110 tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];
1111 if (tel->encap_limit == 0) {
1112 icmpv6_send(skb, ICMPV6_PARAMPROB,
1113 ICMPV6_HDR_FIELD, offset + 2);
1114 return -1;
1115 }
1116 encap_limit = tel->encap_limit - 1;
1117 } else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1118 encap_limit = t->parms.encap_limit;
1119
1120 memcpy(&fl6, &t->fl.u.ip6, sizeof (fl6));
1121 fl6.flowi6_proto = IPPROTO_IPV6;
1122
1123 dsfield = ipv6_get_dsfield(ipv6h);
1124 if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1125 fl6.flowlabel |= (*(__be32 *) ipv6h & IPV6_TCLASS_MASK);
1126 if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
1127 fl6.flowlabel |= (*(__be32 *) ipv6h & IPV6_FLOWLABEL_MASK);
1128 if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
1129 fl6.flowi6_mark = skb->mark;
1130
1131 err = ip6_tnl_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);
1132 if (err != 0) {
1133 if (err == -EMSGSIZE)
1134 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
1135 return -1;
1136 }
1137
1138 return 0;
1139}
1140
1141static netdev_tx_t
1142ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
1143{
1144 struct ip6_tnl *t = netdev_priv(dev);
1145 struct net_device_stats *stats = &t->dev->stats;
1146 int ret;
1147
1148 switch (skb->protocol) {
1149 case htons(ETH_P_IP):
1150 ret = ip4ip6_tnl_xmit(skb, dev);
1151 break;
1152 case htons(ETH_P_IPV6):
1153 ret = ip6ip6_tnl_xmit(skb, dev);
1154 break;
1155 default:
1156 goto tx_err;
1157 }
1158
1159 if (ret < 0)
1160 goto tx_err;
1161
1162 return NETDEV_TX_OK;
1163
1164tx_err:
1165 stats->tx_errors++;
1166 stats->tx_dropped++;
1167 kfree_skb(skb);
1168 return NETDEV_TX_OK;
1169}
1170
1171static void ip6_tnl_link_config(struct ip6_tnl *t)
1172{
1173 struct net_device *dev = t->dev;
1174 struct __ip6_tnl_parm *p = &t->parms;
1175 struct flowi6 *fl6 = &t->fl.u.ip6;
1176
1177 memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
1178 memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
1179
1180
1181 fl6->saddr = p->laddr;
1182 fl6->daddr = p->raddr;
1183 fl6->flowi6_oif = p->link;
1184 fl6->flowlabel = 0;
1185
1186 if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
1187 fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
1188 if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
1189 fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
1190
1191 p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);
1192 p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);
1193
1194 if (p->flags&IP6_TNL_F_CAP_XMIT && p->flags&IP6_TNL_F_CAP_RCV)
1195 dev->flags |= IFF_POINTOPOINT;
1196 else
1197 dev->flags &= ~IFF_POINTOPOINT;
1198
1199 dev->iflink = p->link;
1200
1201 if (p->flags & IP6_TNL_F_CAP_XMIT) {
1202 int strict = (ipv6_addr_type(&p->raddr) &
1203 (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
1204
1205 struct rt6_info *rt = rt6_lookup(dev_net(dev),
1206 &p->raddr, &p->laddr,
1207 p->link, strict);
1208
1209 if (rt == NULL)
1210 return;
1211
1212 if (rt->dst.dev) {
1213 dev->hard_header_len = rt->dst.dev->hard_header_len +
1214 sizeof (struct ipv6hdr);
1215
1216 dev->mtu = rt->dst.dev->mtu - sizeof (struct ipv6hdr);
1217 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1218 dev->mtu-=8;
1219
1220 if (dev->mtu < IPV6_MIN_MTU)
1221 dev->mtu = IPV6_MIN_MTU;
1222 }
1223 ip6_rt_put(rt);
1224 }
1225}
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236static int
1237ip6_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p)
1238{
1239 t->parms.laddr = p->laddr;
1240 t->parms.raddr = p->raddr;
1241 t->parms.flags = p->flags;
1242 t->parms.hop_limit = p->hop_limit;
1243 t->parms.encap_limit = p->encap_limit;
1244 t->parms.flowinfo = p->flowinfo;
1245 t->parms.link = p->link;
1246 t->parms.proto = p->proto;
1247 ip6_tnl_dst_reset(t);
1248 ip6_tnl_link_config(t);
1249 return 0;
1250}
1251
1252static int ip6_tnl_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
1253{
1254 struct net *net = dev_net(t->dev);
1255 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1256 int err;
1257
1258 ip6_tnl_unlink(ip6n, t);
1259 synchronize_net();
1260 err = ip6_tnl_change(t, p);
1261 ip6_tnl_link(ip6n, t);
1262 netdev_state_change(t->dev);
1263 return err;
1264}
1265
1266static void
1267ip6_tnl_parm_from_user(struct __ip6_tnl_parm *p, const struct ip6_tnl_parm *u)
1268{
1269 p->laddr = u->laddr;
1270 p->raddr = u->raddr;
1271 p->flags = u->flags;
1272 p->hop_limit = u->hop_limit;
1273 p->encap_limit = u->encap_limit;
1274 p->flowinfo = u->flowinfo;
1275 p->link = u->link;
1276 p->proto = u->proto;
1277 memcpy(p->name, u->name, sizeof(u->name));
1278}
1279
1280static void
1281ip6_tnl_parm_to_user(struct ip6_tnl_parm *u, const struct __ip6_tnl_parm *p)
1282{
1283 u->laddr = p->laddr;
1284 u->raddr = p->raddr;
1285 u->flags = p->flags;
1286 u->hop_limit = p->hop_limit;
1287 u->encap_limit = p->encap_limit;
1288 u->flowinfo = p->flowinfo;
1289 u->link = p->link;
1290 u->proto = p->proto;
1291 memcpy(u->name, p->name, sizeof(u->name));
1292}
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322static int
1323ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1324{
1325 int err = 0;
1326 struct ip6_tnl_parm p;
1327 struct __ip6_tnl_parm p1;
1328 struct ip6_tnl *t = NULL;
1329 struct net *net = dev_net(dev);
1330 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1331
1332 switch (cmd) {
1333 case SIOCGETTUNNEL:
1334 if (dev == ip6n->fb_tnl_dev) {
1335 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p))) {
1336 err = -EFAULT;
1337 break;
1338 }
1339 ip6_tnl_parm_from_user(&p1, &p);
1340 t = ip6_tnl_locate(net, &p1, 0);
1341 } else {
1342 memset(&p, 0, sizeof(p));
1343 }
1344 if (t == NULL)
1345 t = netdev_priv(dev);
1346 ip6_tnl_parm_to_user(&p, &t->parms);
1347 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof (p))) {
1348 err = -EFAULT;
1349 }
1350 break;
1351 case SIOCADDTUNNEL:
1352 case SIOCCHGTUNNEL:
1353 err = -EPERM;
1354 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1355 break;
1356 err = -EFAULT;
1357 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p)))
1358 break;
1359 err = -EINVAL;
1360 if (p.proto != IPPROTO_IPV6 && p.proto != IPPROTO_IPIP &&
1361 p.proto != 0)
1362 break;
1363 ip6_tnl_parm_from_user(&p1, &p);
1364 t = ip6_tnl_locate(net, &p1, cmd == SIOCADDTUNNEL);
1365 if (dev != ip6n->fb_tnl_dev && cmd == SIOCCHGTUNNEL) {
1366 if (t != NULL) {
1367 if (t->dev != dev) {
1368 err = -EEXIST;
1369 break;
1370 }
1371 } else
1372 t = netdev_priv(dev);
1373
1374 err = ip6_tnl_update(t, &p1);
1375 }
1376 if (t) {
1377 err = 0;
1378 ip6_tnl_parm_to_user(&p, &t->parms);
1379 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1380 err = -EFAULT;
1381
1382 } else
1383 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1384 break;
1385 case SIOCDELTUNNEL:
1386 err = -EPERM;
1387 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1388 break;
1389
1390 if (dev == ip6n->fb_tnl_dev) {
1391 err = -EFAULT;
1392 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof (p)))
1393 break;
1394 err = -ENOENT;
1395 ip6_tnl_parm_from_user(&p1, &p);
1396 t = ip6_tnl_locate(net, &p1, 0);
1397 if (t == NULL)
1398 break;
1399 err = -EPERM;
1400 if (t->dev == ip6n->fb_tnl_dev)
1401 break;
1402 dev = t->dev;
1403 }
1404 err = 0;
1405 unregister_netdevice(dev);
1406 break;
1407 default:
1408 err = -EINVAL;
1409 }
1410 return err;
1411}
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423static int
1424ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
1425{
1426 if (new_mtu < IPV6_MIN_MTU) {
1427 return -EINVAL;
1428 }
1429 dev->mtu = new_mtu;
1430 return 0;
1431}
1432
1433
1434static const struct net_device_ops ip6_tnl_netdev_ops = {
1435 .ndo_uninit = ip6_tnl_dev_uninit,
1436 .ndo_start_xmit = ip6_tnl_xmit,
1437 .ndo_do_ioctl = ip6_tnl_ioctl,
1438 .ndo_change_mtu = ip6_tnl_change_mtu,
1439 .ndo_get_stats = ip6_get_stats,
1440};
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451static void ip6_tnl_dev_setup(struct net_device *dev)
1452{
1453 struct ip6_tnl *t;
1454
1455 dev->netdev_ops = &ip6_tnl_netdev_ops;
1456 dev->destructor = ip6_dev_free;
1457
1458 dev->type = ARPHRD_TUNNEL6;
1459 dev->hard_header_len = LL_MAX_HEADER + sizeof (struct ipv6hdr);
1460 dev->mtu = ETH_DATA_LEN - sizeof (struct ipv6hdr);
1461 t = netdev_priv(dev);
1462 if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1463 dev->mtu-=8;
1464 dev->flags |= IFF_NOARP;
1465 dev->addr_len = sizeof(struct in6_addr);
1466 dev->features |= NETIF_F_NETNS_LOCAL;
1467 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1468}
1469
1470
1471
1472
1473
1474
1475
1476static inline int
1477ip6_tnl_dev_init_gen(struct net_device *dev)
1478{
1479 struct ip6_tnl *t = netdev_priv(dev);
1480
1481 t->dev = dev;
1482 dev->tstats = alloc_percpu(struct pcpu_tstats);
1483 if (!dev->tstats)
1484 return -ENOMEM;
1485 return 0;
1486}
1487
1488
1489
1490
1491
1492
1493static int ip6_tnl_dev_init(struct net_device *dev)
1494{
1495 struct ip6_tnl *t = netdev_priv(dev);
1496 int err = ip6_tnl_dev_init_gen(dev);
1497
1498 if (err)
1499 return err;
1500 ip6_tnl_link_config(t);
1501 return 0;
1502}
1503
1504
1505
1506
1507
1508
1509
1510
1511static int __net_init ip6_fb_tnl_dev_init(struct net_device *dev)
1512{
1513 struct ip6_tnl *t = netdev_priv(dev);
1514 struct net *net = dev_net(dev);
1515 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1516 int err = ip6_tnl_dev_init_gen(dev);
1517
1518 if (err)
1519 return err;
1520
1521 t->parms.proto = IPPROTO_IPV6;
1522 dev_hold(dev);
1523
1524 ip6_tnl_link_config(t);
1525
1526 rcu_assign_pointer(ip6n->tnls_wc[0], t);
1527 return 0;
1528}
1529
1530static int ip6_tnl_validate(struct nlattr *tb[], struct nlattr *data[])
1531{
1532 u8 proto;
1533
1534 if (!data)
1535 return 0;
1536
1537 proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1538 if (proto != IPPROTO_IPV6 &&
1539 proto != IPPROTO_IPIP &&
1540 proto != 0)
1541 return -EINVAL;
1542
1543 return 0;
1544}
1545
1546static void ip6_tnl_netlink_parms(struct nlattr *data[],
1547 struct __ip6_tnl_parm *parms)
1548{
1549 memset(parms, 0, sizeof(*parms));
1550
1551 if (!data)
1552 return;
1553
1554 if (data[IFLA_IPTUN_LINK])
1555 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1556
1557 if (data[IFLA_IPTUN_LOCAL])
1558 nla_memcpy(&parms->laddr, data[IFLA_IPTUN_LOCAL],
1559 sizeof(struct in6_addr));
1560
1561 if (data[IFLA_IPTUN_REMOTE])
1562 nla_memcpy(&parms->raddr, data[IFLA_IPTUN_REMOTE],
1563 sizeof(struct in6_addr));
1564
1565 if (data[IFLA_IPTUN_TTL])
1566 parms->hop_limit = nla_get_u8(data[IFLA_IPTUN_TTL]);
1567
1568 if (data[IFLA_IPTUN_ENCAP_LIMIT])
1569 parms->encap_limit = nla_get_u8(data[IFLA_IPTUN_ENCAP_LIMIT]);
1570
1571 if (data[IFLA_IPTUN_FLOWINFO])
1572 parms->flowinfo = nla_get_be32(data[IFLA_IPTUN_FLOWINFO]);
1573
1574 if (data[IFLA_IPTUN_FLAGS])
1575 parms->flags = nla_get_u32(data[IFLA_IPTUN_FLAGS]);
1576
1577 if (data[IFLA_IPTUN_PROTO])
1578 parms->proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1579}
1580
1581static int ip6_tnl_newlink(struct net *src_net, struct net_device *dev,
1582 struct nlattr *tb[], struct nlattr *data[])
1583{
1584 struct net *net = dev_net(dev);
1585 struct ip6_tnl *nt;
1586
1587 nt = netdev_priv(dev);
1588 ip6_tnl_netlink_parms(data, &nt->parms);
1589
1590 if (ip6_tnl_locate(net, &nt->parms, 0))
1591 return -EEXIST;
1592
1593 return ip6_tnl_create2(dev);
1594}
1595
1596static int ip6_tnl_changelink(struct net_device *dev, struct nlattr *tb[],
1597 struct nlattr *data[])
1598{
1599 struct ip6_tnl *t;
1600 struct __ip6_tnl_parm p;
1601 struct net *net = dev_net(dev);
1602 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1603
1604 if (dev == ip6n->fb_tnl_dev)
1605 return -EINVAL;
1606
1607 ip6_tnl_netlink_parms(data, &p);
1608
1609 t = ip6_tnl_locate(net, &p, 0);
1610
1611 if (t) {
1612 if (t->dev != dev)
1613 return -EEXIST;
1614 } else
1615 t = netdev_priv(dev);
1616
1617 return ip6_tnl_update(t, &p);
1618}
1619
1620static size_t ip6_tnl_get_size(const struct net_device *dev)
1621{
1622 return
1623
1624 nla_total_size(4) +
1625
1626 nla_total_size(sizeof(struct in6_addr)) +
1627
1628 nla_total_size(sizeof(struct in6_addr)) +
1629
1630 nla_total_size(1) +
1631
1632 nla_total_size(1) +
1633
1634 nla_total_size(4) +
1635
1636 nla_total_size(4) +
1637
1638 nla_total_size(1) +
1639 0;
1640}
1641
1642static int ip6_tnl_fill_info(struct sk_buff *skb, const struct net_device *dev)
1643{
1644 struct ip6_tnl *tunnel = netdev_priv(dev);
1645 struct __ip6_tnl_parm *parm = &tunnel->parms;
1646
1647 if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1648 nla_put(skb, IFLA_IPTUN_LOCAL, sizeof(struct in6_addr),
1649 &parm->raddr) ||
1650 nla_put(skb, IFLA_IPTUN_REMOTE, sizeof(struct in6_addr),
1651 &parm->laddr) ||
1652 nla_put_u8(skb, IFLA_IPTUN_TTL, parm->hop_limit) ||
1653 nla_put_u8(skb, IFLA_IPTUN_ENCAP_LIMIT, parm->encap_limit) ||
1654 nla_put_be32(skb, IFLA_IPTUN_FLOWINFO, parm->flowinfo) ||
1655 nla_put_u32(skb, IFLA_IPTUN_FLAGS, parm->flags) ||
1656 nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->proto))
1657 goto nla_put_failure;
1658 return 0;
1659
1660nla_put_failure:
1661 return -EMSGSIZE;
1662}
1663
1664static const struct nla_policy ip6_tnl_policy[IFLA_IPTUN_MAX + 1] = {
1665 [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
1666 [IFLA_IPTUN_LOCAL] = { .len = sizeof(struct in6_addr) },
1667 [IFLA_IPTUN_REMOTE] = { .len = sizeof(struct in6_addr) },
1668 [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
1669 [IFLA_IPTUN_ENCAP_LIMIT] = { .type = NLA_U8 },
1670 [IFLA_IPTUN_FLOWINFO] = { .type = NLA_U32 },
1671 [IFLA_IPTUN_FLAGS] = { .type = NLA_U32 },
1672 [IFLA_IPTUN_PROTO] = { .type = NLA_U8 },
1673};
1674
1675static struct rtnl_link_ops ip6_link_ops __read_mostly = {
1676 .kind = "ip6tnl",
1677 .maxtype = IFLA_IPTUN_MAX,
1678 .policy = ip6_tnl_policy,
1679 .priv_size = sizeof(struct ip6_tnl),
1680 .setup = ip6_tnl_dev_setup,
1681 .validate = ip6_tnl_validate,
1682 .newlink = ip6_tnl_newlink,
1683 .changelink = ip6_tnl_changelink,
1684 .get_size = ip6_tnl_get_size,
1685 .fill_info = ip6_tnl_fill_info,
1686};
1687
1688static struct xfrm6_tunnel ip4ip6_handler __read_mostly = {
1689 .handler = ip4ip6_rcv,
1690 .err_handler = ip4ip6_err,
1691 .priority = 1,
1692};
1693
1694static struct xfrm6_tunnel ip6ip6_handler __read_mostly = {
1695 .handler = ip6ip6_rcv,
1696 .err_handler = ip6ip6_err,
1697 .priority = 1,
1698};
1699
1700static void __net_exit ip6_tnl_destroy_tunnels(struct ip6_tnl_net *ip6n)
1701{
1702 int h;
1703 struct ip6_tnl *t;
1704 LIST_HEAD(list);
1705
1706 for (h = 0; h < HASH_SIZE; h++) {
1707 t = rtnl_dereference(ip6n->tnls_r_l[h]);
1708 while (t != NULL) {
1709 unregister_netdevice_queue(t->dev, &list);
1710 t = rtnl_dereference(t->next);
1711 }
1712 }
1713
1714 t = rtnl_dereference(ip6n->tnls_wc[0]);
1715 unregister_netdevice_queue(t->dev, &list);
1716 unregister_netdevice_many(&list);
1717}
1718
1719static int __net_init ip6_tnl_init_net(struct net *net)
1720{
1721 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1722 struct ip6_tnl *t = NULL;
1723 int err;
1724
1725 ip6n->tnls[0] = ip6n->tnls_wc;
1726 ip6n->tnls[1] = ip6n->tnls_r_l;
1727
1728 err = -ENOMEM;
1729 ip6n->fb_tnl_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6tnl0",
1730 ip6_tnl_dev_setup);
1731
1732 if (!ip6n->fb_tnl_dev)
1733 goto err_alloc_dev;
1734 dev_net_set(ip6n->fb_tnl_dev, net);
1735
1736 err = ip6_fb_tnl_dev_init(ip6n->fb_tnl_dev);
1737 if (err < 0)
1738 goto err_register;
1739
1740 err = register_netdev(ip6n->fb_tnl_dev);
1741 if (err < 0)
1742 goto err_register;
1743
1744 t = netdev_priv(ip6n->fb_tnl_dev);
1745
1746 strcpy(t->parms.name, ip6n->fb_tnl_dev->name);
1747 return 0;
1748
1749err_register:
1750 ip6_dev_free(ip6n->fb_tnl_dev);
1751err_alloc_dev:
1752 return err;
1753}
1754
1755static void __net_exit ip6_tnl_exit_net(struct net *net)
1756{
1757 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1758
1759 rtnl_lock();
1760 ip6_tnl_destroy_tunnels(ip6n);
1761 rtnl_unlock();
1762}
1763
1764static struct pernet_operations ip6_tnl_net_ops = {
1765 .init = ip6_tnl_init_net,
1766 .exit = ip6_tnl_exit_net,
1767 .id = &ip6_tnl_net_id,
1768 .size = sizeof(struct ip6_tnl_net),
1769};
1770
1771
1772
1773
1774
1775
1776
1777static int __init ip6_tunnel_init(void)
1778{
1779 int err;
1780
1781 err = register_pernet_device(&ip6_tnl_net_ops);
1782 if (err < 0)
1783 goto out_pernet;
1784
1785 err = xfrm6_tunnel_register(&ip4ip6_handler, AF_INET);
1786 if (err < 0) {
1787 pr_err("%s: can't register ip4ip6\n", __func__);
1788 goto out_ip4ip6;
1789 }
1790
1791 err = xfrm6_tunnel_register(&ip6ip6_handler, AF_INET6);
1792 if (err < 0) {
1793 pr_err("%s: can't register ip6ip6\n", __func__);
1794 goto out_ip6ip6;
1795 }
1796 err = rtnl_link_register(&ip6_link_ops);
1797 if (err < 0)
1798 goto rtnl_link_failed;
1799
1800 return 0;
1801
1802rtnl_link_failed:
1803 xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6);
1804out_ip6ip6:
1805 xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET);
1806out_ip4ip6:
1807 unregister_pernet_device(&ip6_tnl_net_ops);
1808out_pernet:
1809 return err;
1810}
1811
1812
1813
1814
1815
1816static void __exit ip6_tunnel_cleanup(void)
1817{
1818 rtnl_link_unregister(&ip6_link_ops);
1819 if (xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET))
1820 pr_info("%s: can't deregister ip4ip6\n", __func__);
1821
1822 if (xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6))
1823 pr_info("%s: can't deregister ip6ip6\n", __func__);
1824
1825 unregister_pernet_device(&ip6_tnl_net_ops);
1826}
1827
1828module_init(ip6_tunnel_init);
1829module_exit(ip6_tunnel_cleanup);
1830