1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * IPv6 virtual tunneling interface
5 * Copyright (C) 2013 secunet Security Networks AG
8 * Steffen Klassert <steffen.klassert@secunet.com>
11 * net/ipv6/ip6_tunnel.c
14 #include <linux/module.h>
15 #include <linux/capability.h>
16 #include <linux/errno.h>
17 #include <linux/types.h>
18 #include <linux/sockios.h>
19 #include <linux/icmp.h>
23 #include <linux/net.h>
24 #include <linux/in6.h>
25 #include <linux/netdevice.h>
26 #include <linux/if_arp.h>
27 #include <linux/icmpv6.h>
28 #include <linux/init.h>
29 #include <linux/route.h>
30 #include <linux/rtnetlink.h>
31 #include <linux/netfilter_ipv6.h>
32 #include <linux/slab.h>
33 #include <linux/hash.h>
35 #include <linux/uaccess.h>
36 #include <linux/atomic.h>
40 #include <net/ip_tunnels.h>
42 #include <net/ip6_route.h>
43 #include <net/addrconf.h>
44 #include <net/ip6_tunnel.h>
46 #include <net/net_namespace.h>
47 #include <net/netns/generic.h>
48 #include <linux/etherdevice.h>
50 #define IP6_VTI_HASH_SIZE_SHIFT 5
51 #define IP6_VTI_HASH_SIZE (1 << IP6_VTI_HASH_SIZE_SHIFT)
53 static u32
HASH(const struct in6_addr
*addr1
, const struct in6_addr
*addr2
)
55 u32 hash
= ipv6_addr_hash(addr1
) ^ ipv6_addr_hash(addr2
);
57 return hash_32(hash
, IP6_VTI_HASH_SIZE_SHIFT
);
60 static int vti6_dev_init(struct net_device
*dev
);
61 static void vti6_dev_setup(struct net_device
*dev
);
62 static struct rtnl_link_ops vti6_link_ops __read_mostly
;
64 static unsigned int vti6_net_id __read_mostly
;
66 /* the vti6 tunnel fallback device */
67 struct net_device
*fb_tnl_dev
;
68 /* lists for storing tunnels in use */
69 struct ip6_tnl __rcu
*tnls_r_l
[IP6_VTI_HASH_SIZE
];
70 struct ip6_tnl __rcu
*tnls_wc
[1];
71 struct ip6_tnl __rcu
**tnls
[2];
74 #define for_each_vti6_tunnel_rcu(start) \
75 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
78 * vti6_tnl_lookup - fetch tunnel matching the end-point addresses
79 * @net: network namespace
80 * @remote: the address of the tunnel exit-point
81 * @local: the address of the tunnel entry-point
84 * tunnel matching given end-points if found,
85 * else fallback tunnel if its device is up,
88 static struct ip6_tnl
*
89 vti6_tnl_lookup(struct net
*net
, const struct in6_addr
*remote
,
90 const struct in6_addr
*local
)
92 unsigned int hash
= HASH(remote
, local
);
94 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
97 for_each_vti6_tunnel_rcu(ip6n
->tnls_r_l
[hash
]) {
98 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
99 ipv6_addr_equal(remote
, &t
->parms
.raddr
) &&
100 (t
->dev
->flags
& IFF_UP
))
104 memset(&any
, 0, sizeof(any
));
105 hash
= HASH(&any
, local
);
106 for_each_vti6_tunnel_rcu(ip6n
->tnls_r_l
[hash
]) {
107 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
108 (t
->dev
->flags
& IFF_UP
))
112 hash
= HASH(remote
, &any
);
113 for_each_vti6_tunnel_rcu(ip6n
->tnls_r_l
[hash
]) {
114 if (ipv6_addr_equal(remote
, &t
->parms
.raddr
) &&
115 (t
->dev
->flags
& IFF_UP
))
119 t
= rcu_dereference(ip6n
->tnls_wc
[0]);
120 if (t
&& (t
->dev
->flags
& IFF_UP
))
127 * vti6_tnl_bucket - get head of list matching given tunnel parameters
128 * @ip6n: the private data for ip6_vti in the netns
129 * @p: parameters containing tunnel end-points
132 * vti6_tnl_bucket() returns the head of the list matching the
133 * &struct in6_addr entries laddr and raddr in @p.
135 * Return: head of IPv6 tunnel list
137 static struct ip6_tnl __rcu
**
138 vti6_tnl_bucket(struct vti6_net
*ip6n
, const struct __ip6_tnl_parm
*p
)
140 const struct in6_addr
*remote
= &p
->raddr
;
141 const struct in6_addr
*local
= &p
->laddr
;
145 if (!ipv6_addr_any(remote
) || !ipv6_addr_any(local
)) {
147 h
= HASH(remote
, local
);
149 return &ip6n
->tnls
[prio
][h
];
153 vti6_tnl_link(struct vti6_net
*ip6n
, struct ip6_tnl
*t
)
155 struct ip6_tnl __rcu
**tp
= vti6_tnl_bucket(ip6n
, &t
->parms
);
157 rcu_assign_pointer(t
->next
, rtnl_dereference(*tp
));
158 rcu_assign_pointer(*tp
, t
);
162 vti6_tnl_unlink(struct vti6_net
*ip6n
, struct ip6_tnl
*t
)
164 struct ip6_tnl __rcu
**tp
;
165 struct ip6_tnl
*iter
;
167 for (tp
= vti6_tnl_bucket(ip6n
, &t
->parms
);
168 (iter
= rtnl_dereference(*tp
)) != NULL
;
171 rcu_assign_pointer(*tp
, t
->next
);
177 static void vti6_dev_free(struct net_device
*dev
)
179 free_percpu(dev
->tstats
);
182 static int vti6_tnl_create2(struct net_device
*dev
)
184 struct ip6_tnl
*t
= netdev_priv(dev
);
185 struct net
*net
= dev_net(dev
);
186 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
189 dev
->rtnl_link_ops
= &vti6_link_ops
;
190 err
= register_netdevice(dev
);
194 strcpy(t
->parms
.name
, dev
->name
);
196 vti6_tnl_link(ip6n
, t
);
204 static struct ip6_tnl
*vti6_tnl_create(struct net
*net
, struct __ip6_tnl_parm
*p
)
206 struct net_device
*dev
;
212 if (!dev_valid_name(p
->name
))
214 strlcpy(name
, p
->name
, IFNAMSIZ
);
216 sprintf(name
, "ip6_vti%%d");
219 dev
= alloc_netdev(sizeof(*t
), name
, NET_NAME_UNKNOWN
, vti6_dev_setup
);
223 dev_net_set(dev
, net
);
225 t
= netdev_priv(dev
);
227 t
->net
= dev_net(dev
);
229 err
= vti6_tnl_create2(dev
);
242 * vti6_locate - find or create tunnel matching given parameters
243 * @net: network namespace
244 * @p: tunnel parameters
245 * @create: != 0 if allowed to create new tunnel if no match found
248 * vti6_locate() first tries to locate an existing tunnel
249 * based on @parms. If this is unsuccessful, but @create is set a new
250 * tunnel device is created and registered for use.
253 * matching tunnel or NULL
255 static struct ip6_tnl
*vti6_locate(struct net
*net
, struct __ip6_tnl_parm
*p
,
258 const struct in6_addr
*remote
= &p
->raddr
;
259 const struct in6_addr
*local
= &p
->laddr
;
260 struct ip6_tnl __rcu
**tp
;
262 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
264 for (tp
= vti6_tnl_bucket(ip6n
, p
);
265 (t
= rtnl_dereference(*tp
)) != NULL
;
267 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
268 ipv6_addr_equal(remote
, &t
->parms
.raddr
)) {
277 return vti6_tnl_create(net
, p
);
281 * vti6_dev_uninit - tunnel device uninitializer
282 * @dev: the device to be destroyed
285 * vti6_dev_uninit() removes tunnel from its list
287 static void vti6_dev_uninit(struct net_device
*dev
)
289 struct ip6_tnl
*t
= netdev_priv(dev
);
290 struct vti6_net
*ip6n
= net_generic(t
->net
, vti6_net_id
);
292 if (dev
== ip6n
->fb_tnl_dev
)
293 RCU_INIT_POINTER(ip6n
->tnls_wc
[0], NULL
);
295 vti6_tnl_unlink(ip6n
, t
);
296 dev_put_track(dev
, &t
->dev_tracker
);
299 static int vti6_input_proto(struct sk_buff
*skb
, int nexthdr
, __be32 spi
,
303 const struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
306 t
= vti6_tnl_lookup(dev_net(skb
->dev
), &ipv6h
->saddr
, &ipv6h
->daddr
);
308 if (t
->parms
.proto
!= IPPROTO_IPV6
&& t
->parms
.proto
!= 0) {
313 if (!xfrm6_policy_check(NULL
, XFRM_POLICY_IN
, skb
)) {
318 ipv6h
= ipv6_hdr(skb
);
319 if (!ip6_tnl_rcv_ctl(t
, &ipv6h
->daddr
, &ipv6h
->saddr
)) {
320 t
->dev
->stats
.rx_dropped
++;
327 XFRM_TUNNEL_SKB_CB(skb
)->tunnel
.ip6
= t
;
328 XFRM_SPI_SKB_CB(skb
)->family
= AF_INET6
;
329 XFRM_SPI_SKB_CB(skb
)->daddroff
= offsetof(struct ipv6hdr
, daddr
);
330 return xfrm_input(skb
, nexthdr
, spi
, encap_type
);
339 static int vti6_rcv(struct sk_buff
*skb
)
341 int nexthdr
= skb_network_header(skb
)[IP6CB(skb
)->nhoff
];
343 return vti6_input_proto(skb
, nexthdr
, 0, 0);
346 static int vti6_rcv_cb(struct sk_buff
*skb
, int err
)
348 unsigned short family
;
349 struct net_device
*dev
;
350 struct xfrm_state
*x
;
351 const struct xfrm_mode
*inner_mode
;
352 struct ip6_tnl
*t
= XFRM_TUNNEL_SKB_CB(skb
)->tunnel
.ip6
;
353 u32 orig_mark
= skb
->mark
;
362 dev
->stats
.rx_errors
++;
363 dev
->stats
.rx_dropped
++;
368 x
= xfrm_input_state(skb
);
370 inner_mode
= &x
->inner_mode
;
372 if (x
->sel
.family
== AF_UNSPEC
) {
373 inner_mode
= xfrm_ip2inner_mode(x
, XFRM_MODE_SKB_CB(skb
)->protocol
);
374 if (inner_mode
== NULL
) {
375 XFRM_INC_STATS(dev_net(skb
->dev
),
376 LINUX_MIB_XFRMINSTATEMODEERROR
);
381 family
= inner_mode
->family
;
383 skb
->mark
= be32_to_cpu(t
->parms
.i_key
);
384 ret
= xfrm_policy_check(NULL
, XFRM_POLICY_IN
, skb
, family
);
385 skb
->mark
= orig_mark
;
390 skb_scrub_packet(skb
, !net_eq(t
->net
, dev_net(skb
->dev
)));
392 dev_sw_netstats_rx_add(dev
, skb
->len
);
398 * vti6_addr_conflict - compare packet addresses to tunnel's own
399 * @t: the outgoing tunnel device
400 * @hdr: IPv6 header from the incoming packet
403 * Avoid trivial tunneling loop by checking that tunnel exit-point
404 * doesn't match source of incoming packet.
411 vti6_addr_conflict(const struct ip6_tnl
*t
, const struct ipv6hdr
*hdr
)
413 return ipv6_addr_equal(&t
->parms
.raddr
, &hdr
->saddr
);
416 static bool vti6_state_check(const struct xfrm_state
*x
,
417 const struct in6_addr
*dst
,
418 const struct in6_addr
*src
)
420 xfrm_address_t
*daddr
= (xfrm_address_t
*)dst
;
421 xfrm_address_t
*saddr
= (xfrm_address_t
*)src
;
423 /* if there is no transform then this tunnel is not functional.
424 * Or if the xfrm is not mode tunnel.
426 if (!x
|| x
->props
.mode
!= XFRM_MODE_TUNNEL
||
427 x
->props
.family
!= AF_INET6
)
430 if (ipv6_addr_any(dst
))
431 return xfrm_addr_equal(saddr
, &x
->props
.saddr
, AF_INET6
);
433 if (!xfrm_state_addr_check(x
, daddr
, saddr
, AF_INET6
))
440 * vti6_xmit - send a packet
441 * @skb: the outgoing socket buffer
442 * @dev: the outgoing tunnel device
443 * @fl: the flow informations for the xfrm_lookup
446 vti6_xmit(struct sk_buff
*skb
, struct net_device
*dev
, struct flowi
*fl
)
448 struct ip6_tnl
*t
= netdev_priv(dev
);
449 struct net_device_stats
*stats
= &t
->dev
->stats
;
450 struct dst_entry
*dst
= skb_dst(skb
);
451 struct net_device
*tdev
;
452 struct xfrm_state
*x
;
453 int pkt_len
= skb
->len
;
458 switch (skb
->protocol
) {
459 case htons(ETH_P_IP
): {
462 fl
->u
.ip4
.flowi4_oif
= dev
->ifindex
;
463 fl
->u
.ip4
.flowi4_flags
|= FLOWI_FLAG_ANYSRC
;
464 rt
= __ip_route_output_key(dev_net(dev
), &fl
->u
.ip4
);
466 goto tx_err_link_failure
;
468 skb_dst_set(skb
, dst
);
471 case htons(ETH_P_IPV6
):
472 fl
->u
.ip6
.flowi6_oif
= dev
->ifindex
;
473 fl
->u
.ip6
.flowi6_flags
|= FLOWI_FLAG_ANYSRC
;
474 dst
= ip6_route_output(dev_net(dev
), NULL
, &fl
->u
.ip6
);
478 goto tx_err_link_failure
;
480 skb_dst_set(skb
, dst
);
483 goto tx_err_link_failure
;
488 dst
= xfrm_lookup_route(t
->net
, dst
, fl
, NULL
, 0);
492 goto tx_err_link_failure
;
495 if (dst
->flags
& DST_XFRM_QUEUE
)
499 if (!vti6_state_check(x
, &t
->parms
.raddr
, &t
->parms
.laddr
))
500 goto tx_err_link_failure
;
502 if (!ip6_tnl_xmit_ctl(t
, (const struct in6_addr
*)&x
->props
.saddr
,
503 (const struct in6_addr
*)&x
->id
.daddr
))
504 goto tx_err_link_failure
;
510 net_warn_ratelimited("%s: Local routing loop detected!\n",
512 goto tx_err_dst_release
;
516 if (skb
->len
> mtu
) {
517 skb_dst_update_pmtu_no_confirm(skb
, mtu
);
519 if (skb
->protocol
== htons(ETH_P_IPV6
)) {
520 if (mtu
< IPV6_MIN_MTU
)
523 icmpv6_ndo_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
);
525 if (!(ip_hdr(skb
)->frag_off
& htons(IP_DF
)))
527 icmp_ndo_send(skb
, ICMP_DEST_UNREACH
, ICMP_FRAG_NEEDED
,
532 goto tx_err_dst_release
;
536 skb_scrub_packet(skb
, !net_eq(t
->net
, dev_net(dev
)));
537 skb_dst_set(skb
, dst
);
538 skb
->dev
= skb_dst(skb
)->dev
;
540 err
= dst_output(t
->net
, skb
->sk
, skb
);
541 if (net_xmit_eval(err
) == 0)
543 iptunnel_xmit_stats(dev
, err
);
547 stats
->tx_carrier_errors
++;
548 dst_link_failure(skb
);
555 vti6_tnl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
557 struct ip6_tnl
*t
= netdev_priv(dev
);
558 struct net_device_stats
*stats
= &t
->dev
->stats
;
562 if (!pskb_inet_may_pull(skb
))
565 memset(&fl
, 0, sizeof(fl
));
567 switch (skb
->protocol
) {
568 case htons(ETH_P_IPV6
):
569 if ((t
->parms
.proto
!= IPPROTO_IPV6
&& t
->parms
.proto
!= 0) ||
570 vti6_addr_conflict(t
, ipv6_hdr(skb
)))
573 xfrm_decode_session(skb
, &fl
, AF_INET6
);
574 memset(IP6CB(skb
), 0, sizeof(*IP6CB(skb
)));
576 case htons(ETH_P_IP
):
577 xfrm_decode_session(skb
, &fl
, AF_INET
);
578 memset(IPCB(skb
), 0, sizeof(*IPCB(skb
)));
584 /* override mark with tunnel output key */
585 fl
.flowi_mark
= be32_to_cpu(t
->parms
.o_key
);
587 ret
= vti6_xmit(skb
, dev
, &fl
);
600 static int vti6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
601 u8 type
, u8 code
, int offset
, __be32 info
)
605 struct xfrm_state
*x
;
607 struct ip_esp_hdr
*esph
;
608 struct ip_auth_hdr
*ah
;
609 struct ip_comp_hdr
*ipch
;
610 struct net
*net
= dev_net(skb
->dev
);
611 const struct ipv6hdr
*iph
= (const struct ipv6hdr
*)skb
->data
;
612 int protocol
= iph
->nexthdr
;
614 t
= vti6_tnl_lookup(dev_net(skb
->dev
), &iph
->daddr
, &iph
->saddr
);
618 mark
= be32_to_cpu(t
->parms
.o_key
);
622 esph
= (struct ip_esp_hdr
*)(skb
->data
+ offset
);
626 ah
= (struct ip_auth_hdr
*)(skb
->data
+ offset
);
630 ipch
= (struct ip_comp_hdr
*)(skb
->data
+ offset
);
631 spi
= htonl(ntohs(ipch
->cpi
));
637 if (type
!= ICMPV6_PKT_TOOBIG
&&
638 type
!= NDISC_REDIRECT
)
641 x
= xfrm_state_lookup(net
, mark
, (const xfrm_address_t
*)&iph
->daddr
,
642 spi
, protocol
, AF_INET6
);
646 if (type
== NDISC_REDIRECT
)
647 ip6_redirect(skb
, net
, skb
->dev
->ifindex
, 0,
648 sock_net_uid(net
, NULL
));
650 ip6_update_pmtu(skb
, net
, info
, 0, 0, sock_net_uid(net
, NULL
));
656 static void vti6_link_config(struct ip6_tnl
*t
, bool keep_mtu
)
658 struct net_device
*dev
= t
->dev
;
659 struct __ip6_tnl_parm
*p
= &t
->parms
;
660 struct net_device
*tdev
= NULL
;
663 __dev_addr_set(dev
, &p
->laddr
, sizeof(struct in6_addr
));
664 memcpy(dev
->broadcast
, &p
->raddr
, sizeof(struct in6_addr
));
666 p
->flags
&= ~(IP6_TNL_F_CAP_XMIT
| IP6_TNL_F_CAP_RCV
|
667 IP6_TNL_F_CAP_PER_PACKET
);
668 p
->flags
|= ip6_tnl_get_cap(t
, &p
->laddr
, &p
->raddr
);
670 if (p
->flags
& IP6_TNL_F_CAP_XMIT
&& p
->flags
& IP6_TNL_F_CAP_RCV
)
671 dev
->flags
|= IFF_POINTOPOINT
;
673 dev
->flags
&= ~IFF_POINTOPOINT
;
675 if (keep_mtu
&& dev
->mtu
) {
676 dev
->mtu
= clamp(dev
->mtu
, dev
->min_mtu
, dev
->max_mtu
);
680 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
681 int strict
= (ipv6_addr_type(&p
->raddr
) &
682 (IPV6_ADDR_MULTICAST
| IPV6_ADDR_LINKLOCAL
));
683 struct rt6_info
*rt
= rt6_lookup(t
->net
,
684 &p
->raddr
, &p
->laddr
,
685 p
->link
, NULL
, strict
);
692 if (!tdev
&& p
->link
)
693 tdev
= __dev_get_by_index(t
->net
, p
->link
);
696 mtu
= tdev
->mtu
- sizeof(struct ipv6hdr
);
698 mtu
= ETH_DATA_LEN
- LL_MAX_HEADER
- sizeof(struct ipv6hdr
);
700 dev
->mtu
= max_t(int, mtu
, IPV4_MIN_MTU
);
704 * vti6_tnl_change - update the tunnel parameters
705 * @t: tunnel to be changed
706 * @p: tunnel configuration parameters
707 * @keep_mtu: MTU was set from userspace, don't re-compute it
710 * vti6_tnl_change() updates the tunnel parameters
713 vti6_tnl_change(struct ip6_tnl
*t
, const struct __ip6_tnl_parm
*p
,
716 t
->parms
.laddr
= p
->laddr
;
717 t
->parms
.raddr
= p
->raddr
;
718 t
->parms
.link
= p
->link
;
719 t
->parms
.i_key
= p
->i_key
;
720 t
->parms
.o_key
= p
->o_key
;
721 t
->parms
.proto
= p
->proto
;
722 t
->parms
.fwmark
= p
->fwmark
;
723 dst_cache_reset(&t
->dst_cache
);
724 vti6_link_config(t
, keep_mtu
);
728 static int vti6_update(struct ip6_tnl
*t
, struct __ip6_tnl_parm
*p
,
731 struct net
*net
= dev_net(t
->dev
);
732 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
735 vti6_tnl_unlink(ip6n
, t
);
737 err
= vti6_tnl_change(t
, p
, keep_mtu
);
738 vti6_tnl_link(ip6n
, t
);
739 netdev_state_change(t
->dev
);
744 vti6_parm_from_user(struct __ip6_tnl_parm
*p
, const struct ip6_tnl_parm2
*u
)
753 memcpy(p
->name
, u
->name
, sizeof(u
->name
));
757 vti6_parm_to_user(struct ip6_tnl_parm2
*u
, const struct __ip6_tnl_parm
*p
)
765 u
->i_flags
|= GRE_KEY
;
767 u
->o_flags
|= GRE_KEY
;
770 memcpy(u
->name
, p
->name
, sizeof(u
->name
));
774 * vti6_siocdevprivate - configure vti6 tunnels from userspace
775 * @dev: virtual device associated with tunnel
777 * @data: parameters passed from userspace
778 * @cmd: command to be performed
781 * vti6_siocdevprivate() is used for managing vti6 tunnels
784 * The possible commands are the following:
785 * %SIOCGETTUNNEL: get tunnel parameters for device
786 * %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
787 * %SIOCCHGTUNNEL: change tunnel parameters to those given
788 * %SIOCDELTUNNEL: delete tunnel
790 * The fallback device "ip6_vti0", created during module
791 * initialization, can be used for creating other tunnel devices.
795 * %-EFAULT if unable to copy data to or from userspace,
796 * %-EPERM if current process hasn't %CAP_NET_ADMIN set
797 * %-EINVAL if passed tunnel parameters are invalid,
798 * %-EEXIST if changing a tunnel's parameters would cause a conflict
799 * %-ENODEV if attempting to change or delete a nonexisting device
802 vti6_siocdevprivate(struct net_device
*dev
, struct ifreq
*ifr
, void __user
*data
, int cmd
)
805 struct ip6_tnl_parm2 p
;
806 struct __ip6_tnl_parm p1
;
807 struct ip6_tnl
*t
= NULL
;
808 struct net
*net
= dev_net(dev
);
809 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
811 memset(&p1
, 0, sizeof(p1
));
815 if (dev
== ip6n
->fb_tnl_dev
) {
816 if (copy_from_user(&p
, data
, sizeof(p
))) {
820 vti6_parm_from_user(&p1
, &p
);
821 t
= vti6_locate(net
, &p1
, 0);
823 memset(&p
, 0, sizeof(p
));
826 t
= netdev_priv(dev
);
827 vti6_parm_to_user(&p
, &t
->parms
);
828 if (copy_to_user(data
, &p
, sizeof(p
)))
834 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
837 if (copy_from_user(&p
, data
, sizeof(p
)))
840 if (p
.proto
!= IPPROTO_IPV6
&& p
.proto
!= 0)
842 vti6_parm_from_user(&p1
, &p
);
843 t
= vti6_locate(net
, &p1
, cmd
== SIOCADDTUNNEL
);
844 if (dev
!= ip6n
->fb_tnl_dev
&& cmd
== SIOCCHGTUNNEL
) {
851 t
= netdev_priv(dev
);
853 err
= vti6_update(t
, &p1
, false);
857 vti6_parm_to_user(&p
, &t
->parms
);
858 if (copy_to_user(data
, &p
, sizeof(p
)))
862 err
= (cmd
== SIOCADDTUNNEL
? -ENOBUFS
: -ENOENT
);
866 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
869 if (dev
== ip6n
->fb_tnl_dev
) {
871 if (copy_from_user(&p
, data
, sizeof(p
)))
874 vti6_parm_from_user(&p1
, &p
);
875 t
= vti6_locate(net
, &p1
, 0);
879 if (t
->dev
== ip6n
->fb_tnl_dev
)
884 unregister_netdevice(dev
);
892 static const struct net_device_ops vti6_netdev_ops
= {
893 .ndo_init
= vti6_dev_init
,
894 .ndo_uninit
= vti6_dev_uninit
,
895 .ndo_start_xmit
= vti6_tnl_xmit
,
896 .ndo_siocdevprivate
= vti6_siocdevprivate
,
897 .ndo_get_stats64
= dev_get_tstats64
,
898 .ndo_get_iflink
= ip6_tnl_get_iflink
,
902 * vti6_dev_setup - setup virtual tunnel device
903 * @dev: virtual device associated with tunnel
906 * Initialize function pointers and device parameters
908 static void vti6_dev_setup(struct net_device
*dev
)
910 dev
->netdev_ops
= &vti6_netdev_ops
;
911 dev
->header_ops
= &ip_tunnel_header_ops
;
912 dev
->needs_free_netdev
= true;
913 dev
->priv_destructor
= vti6_dev_free
;
915 dev
->type
= ARPHRD_TUNNEL6
;
916 dev
->min_mtu
= IPV4_MIN_MTU
;
917 dev
->max_mtu
= IP_MAX_MTU
- sizeof(struct ipv6hdr
);
918 dev
->flags
|= IFF_NOARP
;
919 dev
->addr_len
= sizeof(struct in6_addr
);
921 /* This perm addr will be used as interface identifier by IPv6 */
922 dev
->addr_assign_type
= NET_ADDR_RANDOM
;
923 eth_random_addr(dev
->perm_addr
);
927 * vti6_dev_init_gen - general initializer for all tunnel devices
928 * @dev: virtual device associated with tunnel
930 static inline int vti6_dev_init_gen(struct net_device
*dev
)
932 struct ip6_tnl
*t
= netdev_priv(dev
);
935 t
->net
= dev_net(dev
);
936 dev
->tstats
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
939 dev_hold_track(dev
, &t
->dev_tracker
, GFP_KERNEL
);
944 * vti6_dev_init - initializer for all non fallback tunnel devices
945 * @dev: virtual device associated with tunnel
947 static int vti6_dev_init(struct net_device
*dev
)
949 struct ip6_tnl
*t
= netdev_priv(dev
);
950 int err
= vti6_dev_init_gen(dev
);
954 vti6_link_config(t
, true);
959 * vti6_fb_tnl_dev_init - initializer for fallback tunnel device
960 * @dev: fallback device
964 static int __net_init
vti6_fb_tnl_dev_init(struct net_device
*dev
)
966 struct ip6_tnl
*t
= netdev_priv(dev
);
967 struct net
*net
= dev_net(dev
);
968 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
970 t
->parms
.proto
= IPPROTO_IPV6
;
972 rcu_assign_pointer(ip6n
->tnls_wc
[0], t
);
976 static int vti6_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
977 struct netlink_ext_ack
*extack
)
982 static void vti6_netlink_parms(struct nlattr
*data
[],
983 struct __ip6_tnl_parm
*parms
)
985 memset(parms
, 0, sizeof(*parms
));
990 if (data
[IFLA_VTI_LINK
])
991 parms
->link
= nla_get_u32(data
[IFLA_VTI_LINK
]);
993 if (data
[IFLA_VTI_LOCAL
])
994 parms
->laddr
= nla_get_in6_addr(data
[IFLA_VTI_LOCAL
]);
996 if (data
[IFLA_VTI_REMOTE
])
997 parms
->raddr
= nla_get_in6_addr(data
[IFLA_VTI_REMOTE
]);
999 if (data
[IFLA_VTI_IKEY
])
1000 parms
->i_key
= nla_get_be32(data
[IFLA_VTI_IKEY
]);
1002 if (data
[IFLA_VTI_OKEY
])
1003 parms
->o_key
= nla_get_be32(data
[IFLA_VTI_OKEY
]);
1005 if (data
[IFLA_VTI_FWMARK
])
1006 parms
->fwmark
= nla_get_u32(data
[IFLA_VTI_FWMARK
]);
1009 static int vti6_newlink(struct net
*src_net
, struct net_device
*dev
,
1010 struct nlattr
*tb
[], struct nlattr
*data
[],
1011 struct netlink_ext_ack
*extack
)
1013 struct net
*net
= dev_net(dev
);
1016 nt
= netdev_priv(dev
);
1017 vti6_netlink_parms(data
, &nt
->parms
);
1019 nt
->parms
.proto
= IPPROTO_IPV6
;
1021 if (vti6_locate(net
, &nt
->parms
, 0))
1024 return vti6_tnl_create2(dev
);
1027 static void vti6_dellink(struct net_device
*dev
, struct list_head
*head
)
1029 struct net
*net
= dev_net(dev
);
1030 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
1032 if (dev
!= ip6n
->fb_tnl_dev
)
1033 unregister_netdevice_queue(dev
, head
);
1036 static int vti6_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
1037 struct nlattr
*data
[],
1038 struct netlink_ext_ack
*extack
)
1041 struct __ip6_tnl_parm p
;
1042 struct net
*net
= dev_net(dev
);
1043 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
1045 if (dev
== ip6n
->fb_tnl_dev
)
1048 vti6_netlink_parms(data
, &p
);
1050 t
= vti6_locate(net
, &p
, 0);
1056 t
= netdev_priv(dev
);
1058 return vti6_update(t
, &p
, tb
&& tb
[IFLA_MTU
]);
1061 static size_t vti6_get_size(const struct net_device
*dev
)
1066 /* IFLA_VTI_LOCAL */
1067 nla_total_size(sizeof(struct in6_addr
)) +
1068 /* IFLA_VTI_REMOTE */
1069 nla_total_size(sizeof(struct in6_addr
)) +
1074 /* IFLA_VTI_FWMARK */
1079 static int vti6_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
1081 struct ip6_tnl
*tunnel
= netdev_priv(dev
);
1082 struct __ip6_tnl_parm
*parm
= &tunnel
->parms
;
1084 if (nla_put_u32(skb
, IFLA_VTI_LINK
, parm
->link
) ||
1085 nla_put_in6_addr(skb
, IFLA_VTI_LOCAL
, &parm
->laddr
) ||
1086 nla_put_in6_addr(skb
, IFLA_VTI_REMOTE
, &parm
->raddr
) ||
1087 nla_put_be32(skb
, IFLA_VTI_IKEY
, parm
->i_key
) ||
1088 nla_put_be32(skb
, IFLA_VTI_OKEY
, parm
->o_key
) ||
1089 nla_put_u32(skb
, IFLA_VTI_FWMARK
, parm
->fwmark
))
1090 goto nla_put_failure
;
1097 static const struct nla_policy vti6_policy
[IFLA_VTI_MAX
+ 1] = {
1098 [IFLA_VTI_LINK
] = { .type
= NLA_U32
},
1099 [IFLA_VTI_LOCAL
] = { .len
= sizeof(struct in6_addr
) },
1100 [IFLA_VTI_REMOTE
] = { .len
= sizeof(struct in6_addr
) },
1101 [IFLA_VTI_IKEY
] = { .type
= NLA_U32
},
1102 [IFLA_VTI_OKEY
] = { .type
= NLA_U32
},
1103 [IFLA_VTI_FWMARK
] = { .type
= NLA_U32
},
1106 static struct rtnl_link_ops vti6_link_ops __read_mostly
= {
1108 .maxtype
= IFLA_VTI_MAX
,
1109 .policy
= vti6_policy
,
1110 .priv_size
= sizeof(struct ip6_tnl
),
1111 .setup
= vti6_dev_setup
,
1112 .validate
= vti6_validate
,
1113 .newlink
= vti6_newlink
,
1114 .dellink
= vti6_dellink
,
1115 .changelink
= vti6_changelink
,
1116 .get_size
= vti6_get_size
,
1117 .fill_info
= vti6_fill_info
,
1118 .get_link_net
= ip6_tnl_get_link_net
,
1121 static void __net_exit
vti6_destroy_tunnels(struct vti6_net
*ip6n
,
1122 struct list_head
*list
)
1127 for (h
= 0; h
< IP6_VTI_HASH_SIZE
; h
++) {
1128 t
= rtnl_dereference(ip6n
->tnls_r_l
[h
]);
1130 unregister_netdevice_queue(t
->dev
, list
);
1131 t
= rtnl_dereference(t
->next
);
1135 t
= rtnl_dereference(ip6n
->tnls_wc
[0]);
1137 unregister_netdevice_queue(t
->dev
, list
);
1140 static int __net_init
vti6_init_net(struct net
*net
)
1142 struct vti6_net
*ip6n
= net_generic(net
, vti6_net_id
);
1143 struct ip6_tnl
*t
= NULL
;
1146 ip6n
->tnls
[0] = ip6n
->tnls_wc
;
1147 ip6n
->tnls
[1] = ip6n
->tnls_r_l
;
1149 if (!net_has_fallback_tunnels(net
))
1152 ip6n
->fb_tnl_dev
= alloc_netdev(sizeof(struct ip6_tnl
), "ip6_vti0",
1153 NET_NAME_UNKNOWN
, vti6_dev_setup
);
1155 if (!ip6n
->fb_tnl_dev
)
1157 dev_net_set(ip6n
->fb_tnl_dev
, net
);
1158 ip6n
->fb_tnl_dev
->rtnl_link_ops
= &vti6_link_ops
;
1160 err
= vti6_fb_tnl_dev_init(ip6n
->fb_tnl_dev
);
1164 err
= register_netdev(ip6n
->fb_tnl_dev
);
1168 t
= netdev_priv(ip6n
->fb_tnl_dev
);
1170 strcpy(t
->parms
.name
, ip6n
->fb_tnl_dev
->name
);
1174 free_netdev(ip6n
->fb_tnl_dev
);
1179 static void __net_exit
vti6_exit_batch_net(struct list_head
*net_list
)
1181 struct vti6_net
*ip6n
;
1186 list_for_each_entry(net
, net_list
, exit_list
) {
1187 ip6n
= net_generic(net
, vti6_net_id
);
1188 vti6_destroy_tunnels(ip6n
, &list
);
1190 unregister_netdevice_many(&list
);
1194 static struct pernet_operations vti6_net_ops
= {
1195 .init
= vti6_init_net
,
1196 .exit_batch
= vti6_exit_batch_net
,
1198 .size
= sizeof(struct vti6_net
),
1201 static struct xfrm6_protocol vti_esp6_protocol __read_mostly
= {
1202 .handler
= vti6_rcv
,
1203 .input_handler
= vti6_input_proto
,
1204 .cb_handler
= vti6_rcv_cb
,
1205 .err_handler
= vti6_err
,
1209 static struct xfrm6_protocol vti_ah6_protocol __read_mostly
= {
1210 .handler
= vti6_rcv
,
1211 .input_handler
= vti6_input_proto
,
1212 .cb_handler
= vti6_rcv_cb
,
1213 .err_handler
= vti6_err
,
1217 static struct xfrm6_protocol vti_ipcomp6_protocol __read_mostly
= {
1218 .handler
= vti6_rcv
,
1219 .input_handler
= vti6_input_proto
,
1220 .cb_handler
= vti6_rcv_cb
,
1221 .err_handler
= vti6_err
,
1225 #if IS_REACHABLE(CONFIG_INET6_XFRM_TUNNEL)
1226 static int vti6_rcv_tunnel(struct sk_buff
*skb
)
1228 const xfrm_address_t
*saddr
;
1231 saddr
= (const xfrm_address_t
*)&ipv6_hdr(skb
)->saddr
;
1232 spi
= xfrm6_tunnel_spi_lookup(dev_net(skb
->dev
), saddr
);
1234 return vti6_input_proto(skb
, IPPROTO_IPV6
, spi
, 0);
1237 static struct xfrm6_tunnel vti_ipv6_handler __read_mostly
= {
1238 .handler
= vti6_rcv_tunnel
,
1239 .cb_handler
= vti6_rcv_cb
,
1240 .err_handler
= vti6_err
,
1244 static struct xfrm6_tunnel vti_ip6ip_handler __read_mostly
= {
1245 .handler
= vti6_rcv_tunnel
,
1246 .cb_handler
= vti6_rcv_cb
,
1247 .err_handler
= vti6_err
,
1253 * vti6_tunnel_init - register protocol and reserve needed resources
1255 * Return: 0 on success
1257 static int __init
vti6_tunnel_init(void)
1262 msg
= "tunnel device";
1263 err
= register_pernet_device(&vti6_net_ops
);
1265 goto pernet_dev_failed
;
1267 msg
= "tunnel protocols";
1268 err
= xfrm6_protocol_register(&vti_esp6_protocol
, IPPROTO_ESP
);
1270 goto xfrm_proto_esp_failed
;
1271 err
= xfrm6_protocol_register(&vti_ah6_protocol
, IPPROTO_AH
);
1273 goto xfrm_proto_ah_failed
;
1274 err
= xfrm6_protocol_register(&vti_ipcomp6_protocol
, IPPROTO_COMP
);
1276 goto xfrm_proto_comp_failed
;
1277 #if IS_REACHABLE(CONFIG_INET6_XFRM_TUNNEL)
1278 msg
= "ipv6 tunnel";
1279 err
= xfrm6_tunnel_register(&vti_ipv6_handler
, AF_INET6
);
1281 goto vti_tunnel_ipv6_failed
;
1282 err
= xfrm6_tunnel_register(&vti_ip6ip_handler
, AF_INET
);
1284 goto vti_tunnel_ip6ip_failed
;
1287 msg
= "netlink interface";
1288 err
= rtnl_link_register(&vti6_link_ops
);
1290 goto rtnl_link_failed
;
1295 #if IS_REACHABLE(CONFIG_INET6_XFRM_TUNNEL)
1296 err
= xfrm6_tunnel_deregister(&vti_ip6ip_handler
, AF_INET
);
1297 vti_tunnel_ip6ip_failed
:
1298 err
= xfrm6_tunnel_deregister(&vti_ipv6_handler
, AF_INET6
);
1299 vti_tunnel_ipv6_failed
:
1301 xfrm6_protocol_deregister(&vti_ipcomp6_protocol
, IPPROTO_COMP
);
1302 xfrm_proto_comp_failed
:
1303 xfrm6_protocol_deregister(&vti_ah6_protocol
, IPPROTO_AH
);
1304 xfrm_proto_ah_failed
:
1305 xfrm6_protocol_deregister(&vti_esp6_protocol
, IPPROTO_ESP
);
1306 xfrm_proto_esp_failed
:
1307 unregister_pernet_device(&vti6_net_ops
);
1309 pr_err("vti6 init: failed to register %s\n", msg
);
1314 * vti6_tunnel_cleanup - free resources and unregister protocol
1316 static void __exit
vti6_tunnel_cleanup(void)
1318 rtnl_link_unregister(&vti6_link_ops
);
1319 #if IS_REACHABLE(CONFIG_INET6_XFRM_TUNNEL)
1320 xfrm6_tunnel_deregister(&vti_ip6ip_handler
, AF_INET
);
1321 xfrm6_tunnel_deregister(&vti_ipv6_handler
, AF_INET6
);
1323 xfrm6_protocol_deregister(&vti_ipcomp6_protocol
, IPPROTO_COMP
);
1324 xfrm6_protocol_deregister(&vti_ah6_protocol
, IPPROTO_AH
);
1325 xfrm6_protocol_deregister(&vti_esp6_protocol
, IPPROTO_ESP
);
1326 unregister_pernet_device(&vti6_net_ops
);
1329 module_init(vti6_tunnel_init
);
1330 module_exit(vti6_tunnel_cleanup
);
1331 MODULE_LICENSE("GPL");
1332 MODULE_ALIAS_RTNL_LINK("vti6");
1333 MODULE_ALIAS_NETDEV("ip6_vti0");
1334 MODULE_AUTHOR("Steffen Klassert");
1335 MODULE_DESCRIPTION("IPv6 virtual tunnel interface");