2 * IPv6 tunneling device
3 * Linux INET6 implementation
6 * Ville Nuorvala <vnuorval@tcs.hut.fi>
7 * Yasuyuki Kozakai <kozakai@linux-ipv6.org>
12 * linux/net/ipv6/sit.c and linux/net/ipv4/ipip.c
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License
18 * as published by the Free Software Foundation; either version
19 * 2 of the License, or (at your option) any later version.
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>
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>
43 #include <asm/uaccess.h>
44 #include <asm/atomic.h>
49 #include <net/ip6_route.h>
50 #include <net/addrconf.h>
51 #include <net/ip6_tunnel.h>
53 #include <net/dsfield.h>
54 #include <net/inet_ecn.h>
56 MODULE_AUTHOR("Ville Nuorvala");
57 MODULE_DESCRIPTION("IPv6 tunneling device");
58 MODULE_LICENSE("GPL");
60 #define IPV6_TLV_TEL_DST_SIZE 8
63 #define IP6_TNL_TRACE(x...) printk(KERN_DEBUG "%s:" x "\n", __FUNCTION__)
65 #define IP6_TNL_TRACE(x...) do {;} while(0)
68 #define IPV6_TCLASS_MASK (IPV6_FLOWINFO_MASK & ~IPV6_FLOWLABEL_MASK)
69 #define IPV6_TCLASS_SHIFT 20
73 #define HASH(addr) ((__force u32)((addr)->s6_addr32[0] ^ (addr)->s6_addr32[1] ^ \
74 (addr)->s6_addr32[2] ^ (addr)->s6_addr32[3]) & \
77 static int ip6_fb_tnl_dev_init(struct net_device
*dev
);
78 static int ip6_tnl_dev_init(struct net_device
*dev
);
79 static void ip6_tnl_dev_setup(struct net_device
*dev
);
81 /* the IPv6 tunnel fallback device */
82 static struct net_device
*ip6_fb_tnl_dev
;
85 /* lists for storing tunnels in use */
86 static struct ip6_tnl
*tnls_r_l
[HASH_SIZE
];
87 static struct ip6_tnl
*tnls_wc
[1];
88 static struct ip6_tnl
**tnls
[2] = { tnls_wc
, tnls_r_l
};
90 /* lock for the tunnel lists */
91 static DEFINE_RWLOCK(ip6_tnl_lock
);
93 static inline struct dst_entry
*ip6_tnl_dst_check(struct ip6_tnl
*t
)
95 struct dst_entry
*dst
= t
->dst_cache
;
97 if (dst
&& dst
->obsolete
&&
98 dst
->ops
->check(dst
, t
->dst_cookie
) == NULL
) {
107 static inline void ip6_tnl_dst_reset(struct ip6_tnl
*t
)
109 dst_release(t
->dst_cache
);
113 static inline void ip6_tnl_dst_store(struct ip6_tnl
*t
, struct dst_entry
*dst
)
115 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
116 t
->dst_cookie
= rt
->rt6i_node
? rt
->rt6i_node
->fn_sernum
: 0;
117 dst_release(t
->dst_cache
);
122 * ip6_tnl_lookup - fetch tunnel matching the end-point addresses
123 * @remote: the address of the tunnel exit-point
124 * @local: the address of the tunnel entry-point
127 * tunnel matching given end-points if found,
128 * else fallback tunnel if its device is up,
132 static struct ip6_tnl
*
133 ip6_tnl_lookup(struct in6_addr
*remote
, struct in6_addr
*local
)
135 unsigned h0
= HASH(remote
);
136 unsigned h1
= HASH(local
);
139 for (t
= tnls_r_l
[h0
^ h1
]; t
; t
= t
->next
) {
140 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
141 ipv6_addr_equal(remote
, &t
->parms
.raddr
) &&
142 (t
->dev
->flags
& IFF_UP
))
145 if ((t
= tnls_wc
[0]) != NULL
&& (t
->dev
->flags
& IFF_UP
))
152 * ip6_tnl_bucket - get head of list matching given tunnel parameters
153 * @p: parameters containing tunnel end-points
156 * ip6_tnl_bucket() returns the head of the list matching the
157 * &struct in6_addr entries laddr and raddr in @p.
159 * Return: head of IPv6 tunnel list
162 static struct ip6_tnl
**
163 ip6_tnl_bucket(struct ip6_tnl_parm
*p
)
165 struct in6_addr
*remote
= &p
->raddr
;
166 struct in6_addr
*local
= &p
->laddr
;
170 if (!ipv6_addr_any(remote
) || !ipv6_addr_any(local
)) {
172 h
= HASH(remote
) ^ HASH(local
);
174 return &tnls
[prio
][h
];
178 * ip6_tnl_link - add tunnel to hash table
179 * @t: tunnel to be added
183 ip6_tnl_link(struct ip6_tnl
*t
)
185 struct ip6_tnl
**tp
= ip6_tnl_bucket(&t
->parms
);
188 write_lock_bh(&ip6_tnl_lock
);
190 write_unlock_bh(&ip6_tnl_lock
);
194 * ip6_tnl_unlink - remove tunnel from hash table
195 * @t: tunnel to be removed
199 ip6_tnl_unlink(struct ip6_tnl
*t
)
203 for (tp
= ip6_tnl_bucket(&t
->parms
); *tp
; tp
= &(*tp
)->next
) {
205 write_lock_bh(&ip6_tnl_lock
);
207 write_unlock_bh(&ip6_tnl_lock
);
214 * ip6_tnl_create() - create a new tunnel
215 * @p: tunnel parameters
216 * @pt: pointer to new tunnel
219 * Create tunnel matching given parameters.
222 * created tunnel or NULL
225 static struct ip6_tnl
*ip6_tnl_create(struct ip6_tnl_parm
*p
)
227 struct net_device
*dev
;
233 strlcpy(name
, p
->name
, IFNAMSIZ
);
235 sprintf(name
, "ip6tnl%%d");
237 dev
= alloc_netdev(sizeof (*t
), name
, ip6_tnl_dev_setup
);
241 if (strchr(name
, '%')) {
242 if (dev_alloc_name(dev
, name
) < 0)
246 t
= netdev_priv(dev
);
247 dev
->init
= ip6_tnl_dev_init
;
250 if ((err
= register_netdevice(dev
)) < 0)
264 * ip6_tnl_locate - find or create tunnel matching given parameters
265 * @p: tunnel parameters
266 * @create: != 0 if allowed to create new tunnel if no match found
269 * ip6_tnl_locate() first tries to locate an existing tunnel
270 * based on @parms. If this is unsuccessful, but @create is set a new
271 * tunnel device is created and registered for use.
274 * matching tunnel or NULL
277 static struct ip6_tnl
*ip6_tnl_locate(struct ip6_tnl_parm
*p
, int create
)
279 struct in6_addr
*remote
= &p
->raddr
;
280 struct in6_addr
*local
= &p
->laddr
;
283 for (t
= *ip6_tnl_bucket(p
); t
; t
= t
->next
) {
284 if (ipv6_addr_equal(local
, &t
->parms
.laddr
) &&
285 ipv6_addr_equal(remote
, &t
->parms
.raddr
))
290 return ip6_tnl_create(p
);
294 * ip6_tnl_dev_uninit - tunnel device uninitializer
295 * @dev: the device to be destroyed
298 * ip6_tnl_dev_uninit() removes tunnel from its list
302 ip6_tnl_dev_uninit(struct net_device
*dev
)
304 struct ip6_tnl
*t
= netdev_priv(dev
);
306 if (dev
== ip6_fb_tnl_dev
) {
307 write_lock_bh(&ip6_tnl_lock
);
309 write_unlock_bh(&ip6_tnl_lock
);
313 ip6_tnl_dst_reset(t
);
318 * parse_tvl_tnl_enc_lim - handle encapsulation limit option
319 * @skb: received socket buffer
322 * 0 if none was found,
323 * else index to encapsulation limit
327 parse_tlv_tnl_enc_lim(struct sk_buff
*skb
, __u8
* raw
)
329 struct ipv6hdr
*ipv6h
= (struct ipv6hdr
*) raw
;
330 __u8 nexthdr
= ipv6h
->nexthdr
;
331 __u16 off
= sizeof (*ipv6h
);
333 while (ipv6_ext_hdr(nexthdr
) && nexthdr
!= NEXTHDR_NONE
) {
335 struct ipv6_opt_hdr
*hdr
;
336 if (raw
+ off
+ sizeof (*hdr
) > skb
->data
&&
337 !pskb_may_pull(skb
, raw
- skb
->data
+ off
+ sizeof (*hdr
)))
340 hdr
= (struct ipv6_opt_hdr
*) (raw
+ off
);
341 if (nexthdr
== NEXTHDR_FRAGMENT
) {
342 struct frag_hdr
*frag_hdr
= (struct frag_hdr
*) hdr
;
343 if (frag_hdr
->frag_off
)
346 } else if (nexthdr
== NEXTHDR_AUTH
) {
347 optlen
= (hdr
->hdrlen
+ 2) << 2;
349 optlen
= ipv6_optlen(hdr
);
351 if (nexthdr
== NEXTHDR_DEST
) {
354 struct ipv6_tlv_tnl_enc_lim
*tel
;
356 /* No more room for encapsulation limit */
357 if (i
+ sizeof (*tel
) > off
+ optlen
)
360 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &raw
[i
];
361 /* return index of option if found and valid */
362 if (tel
->type
== IPV6_TLV_TNL_ENCAP_LIMIT
&&
365 /* else jump to next option */
367 i
+= tel
->length
+ 2;
372 nexthdr
= hdr
->nexthdr
;
379 * ip6_tnl_err - tunnel error handler
382 * ip6_tnl_err() should handle errors in the tunnel according
383 * to the specifications in RFC 2473.
387 ip6_tnl_err(struct sk_buff
*skb
, __u8 ipproto
, struct inet6_skb_parm
*opt
,
388 int *type
, int *code
, int *msg
, __u32
*info
, int offset
)
390 struct ipv6hdr
*ipv6h
= (struct ipv6hdr
*) skb
->data
;
393 int rel_type
= ICMPV6_DEST_UNREACH
;
394 int rel_code
= ICMPV6_ADDR_UNREACH
;
399 /* If the packet doesn't contain the original IPv6 header we are
400 in trouble since we might need the source address for further
401 processing of the error. */
403 read_lock(&ip6_tnl_lock
);
404 if ((t
= ip6_tnl_lookup(&ipv6h
->daddr
, &ipv6h
->saddr
)) == NULL
)
407 if (t
->parms
.proto
!= ipproto
&& t
->parms
.proto
!= 0)
414 struct ipv6_tlv_tnl_enc_lim
*tel
;
416 case ICMPV6_DEST_UNREACH
:
419 "%s: Path to destination invalid "
420 "or inactive!\n", t
->parms
.name
);
423 case ICMPV6_TIME_EXCEED
:
424 if ((*code
) == ICMPV6_EXC_HOPLIMIT
) {
427 "%s: Too small hop limit or "
428 "routing loop in tunnel!\n",
433 case ICMPV6_PARAMPROB
:
435 if ((*code
) == ICMPV6_HDR_FIELD
)
436 teli
= parse_tlv_tnl_enc_lim(skb
, skb
->data
);
438 if (teli
&& teli
== *info
- 2) {
439 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &skb
->data
[teli
];
440 if (tel
->encap_limit
== 0) {
443 "%s: Too small encapsulation "
444 "limit or routing loop in "
445 "tunnel!\n", t
->parms
.name
);
448 } else if (net_ratelimit()) {
450 "%s: Recipient unable to parse tunneled "
451 "packet!\n ", t
->parms
.name
);
454 case ICMPV6_PKT_TOOBIG
:
455 mtu
= *info
- offset
;
456 if (mtu
< IPV6_MIN_MTU
)
460 if ((len
= sizeof (*ipv6h
) + ntohs(ipv6h
->payload_len
)) > mtu
) {
461 rel_type
= ICMPV6_PKT_TOOBIG
;
475 read_unlock(&ip6_tnl_lock
);
480 ip4ip6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
481 int type
, int code
, int offset
, __be32 info
)
486 __u32 rel_info
= ntohl(info
);
488 struct sk_buff
*skb2
;
493 err
= ip6_tnl_err(skb
, IPPROTO_IPIP
, opt
, &rel_type
, &rel_code
,
494 &rel_msg
, &rel_info
, offset
);
502 case ICMPV6_DEST_UNREACH
:
503 if (rel_code
!= ICMPV6_ADDR_UNREACH
)
505 rel_type
= ICMP_DEST_UNREACH
;
506 rel_code
= ICMP_HOST_UNREACH
;
508 case ICMPV6_PKT_TOOBIG
:
511 rel_type
= ICMP_DEST_UNREACH
;
512 rel_code
= ICMP_FRAG_NEEDED
;
518 if (!pskb_may_pull(skb
, offset
+ sizeof(struct iphdr
)))
521 skb2
= skb_clone(skb
, GFP_ATOMIC
);
525 dst_release(skb2
->dst
);
527 skb_pull(skb2
, offset
);
528 skb_reset_network_header(skb2
);
531 /* Try to guess incoming interface */
532 memset(&fl
, 0, sizeof(fl
));
533 fl
.fl4_dst
= eiph
->saddr
;
534 fl
.fl4_tos
= RT_TOS(eiph
->tos
);
535 fl
.proto
= IPPROTO_IPIP
;
536 if (ip_route_output_key(&init_net
, &rt
, &fl
))
539 skb2
->dev
= rt
->u
.dst
.dev
;
541 /* route "incoming" packet */
542 if (rt
->rt_flags
& RTCF_LOCAL
) {
545 fl
.fl4_dst
= eiph
->daddr
;
546 fl
.fl4_src
= eiph
->saddr
;
547 fl
.fl4_tos
= eiph
->tos
;
548 if (ip_route_output_key(&init_net
, &rt
, &fl
) ||
549 rt
->u
.dst
.dev
->type
!= ARPHRD_TUNNEL
) {
553 skb2
->dst
= (struct dst_entry
*)rt
;
556 if (ip_route_input(skb2
, eiph
->daddr
, eiph
->saddr
, eiph
->tos
,
558 skb2
->dst
->dev
->type
!= ARPHRD_TUNNEL
)
562 /* change mtu on this route */
563 if (rel_type
== ICMP_DEST_UNREACH
&& rel_code
== ICMP_FRAG_NEEDED
) {
564 if (rel_info
> dst_mtu(skb2
->dst
))
567 skb2
->dst
->ops
->update_pmtu(skb2
->dst
, rel_info
);
570 icmp_send(skb2
, rel_type
, rel_code
, htonl(rel_info
));
578 ip6ip6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
579 int type
, int code
, int offset
, __be32 info
)
584 __u32 rel_info
= ntohl(info
);
587 err
= ip6_tnl_err(skb
, IPPROTO_IPV6
, opt
, &rel_type
, &rel_code
,
588 &rel_msg
, &rel_info
, offset
);
592 if (rel_msg
&& pskb_may_pull(skb
, offset
+ sizeof(struct ipv6hdr
))) {
594 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
599 dst_release(skb2
->dst
);
601 skb_pull(skb2
, offset
);
602 skb_reset_network_header(skb2
);
604 /* Try to guess incoming interface */
605 rt
= rt6_lookup(&init_net
, &ipv6_hdr(skb2
)->saddr
, NULL
, 0, 0);
607 if (rt
&& rt
->rt6i_dev
)
608 skb2
->dev
= rt
->rt6i_dev
;
610 icmpv6_send(skb2
, rel_type
, rel_code
, rel_info
, skb2
->dev
);
613 dst_release(&rt
->u
.dst
);
621 static void ip4ip6_dscp_ecn_decapsulate(struct ip6_tnl
*t
,
622 struct ipv6hdr
*ipv6h
,
625 __u8 dsfield
= ipv6_get_dsfield(ipv6h
) & ~INET_ECN_MASK
;
627 if (t
->parms
.flags
& IP6_TNL_F_RCV_DSCP_COPY
)
628 ipv4_change_dsfield(ip_hdr(skb
), INET_ECN_MASK
, dsfield
);
630 if (INET_ECN_is_ce(dsfield
))
631 IP_ECN_set_ce(ip_hdr(skb
));
634 static void ip6ip6_dscp_ecn_decapsulate(struct ip6_tnl
*t
,
635 struct ipv6hdr
*ipv6h
,
638 if (t
->parms
.flags
& IP6_TNL_F_RCV_DSCP_COPY
)
639 ipv6_copy_dscp(ipv6_get_dsfield(ipv6h
), ipv6_hdr(skb
));
641 if (INET_ECN_is_ce(ipv6_get_dsfield(ipv6h
)))
642 IP6_ECN_set_ce(ipv6_hdr(skb
));
645 static inline int ip6_tnl_rcv_ctl(struct ip6_tnl
*t
)
647 struct ip6_tnl_parm
*p
= &t
->parms
;
650 if (p
->flags
& IP6_TNL_F_CAP_RCV
) {
651 struct net_device
*ldev
= NULL
;
654 ldev
= dev_get_by_index(&init_net
, p
->link
);
656 if ((ipv6_addr_is_multicast(&p
->laddr
) ||
657 likely(ipv6_chk_addr(&init_net
, &p
->laddr
, ldev
, 0))) &&
658 likely(!ipv6_chk_addr(&init_net
, &p
->raddr
, NULL
, 0)))
668 * ip6_tnl_rcv - decapsulate IPv6 packet and retransmit it locally
669 * @skb: received socket buffer
670 * @protocol: ethernet protocol ID
671 * @dscp_ecn_decapsulate: the function to decapsulate DSCP code and ECN
676 static int ip6_tnl_rcv(struct sk_buff
*skb
, __u16 protocol
,
678 void (*dscp_ecn_decapsulate
)(struct ip6_tnl
*t
,
679 struct ipv6hdr
*ipv6h
,
680 struct sk_buff
*skb
))
683 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
685 read_lock(&ip6_tnl_lock
);
687 if ((t
= ip6_tnl_lookup(&ipv6h
->saddr
, &ipv6h
->daddr
)) != NULL
) {
688 if (t
->parms
.proto
!= ipproto
&& t
->parms
.proto
!= 0) {
689 read_unlock(&ip6_tnl_lock
);
693 if (!xfrm6_policy_check(NULL
, XFRM_POLICY_IN
, skb
)) {
694 read_unlock(&ip6_tnl_lock
);
698 if (!ip6_tnl_rcv_ctl(t
)) {
699 t
->stat
.rx_dropped
++;
700 read_unlock(&ip6_tnl_lock
);
704 skb
->mac_header
= skb
->network_header
;
705 skb_reset_network_header(skb
);
706 skb
->protocol
= htons(protocol
);
707 skb
->pkt_type
= PACKET_HOST
;
708 memset(skb
->cb
, 0, sizeof(struct inet6_skb_parm
));
710 dst_release(skb
->dst
);
714 dscp_ecn_decapsulate(t
, ipv6h
, skb
);
716 t
->stat
.rx_packets
++;
717 t
->stat
.rx_bytes
+= skb
->len
;
719 read_unlock(&ip6_tnl_lock
);
722 read_unlock(&ip6_tnl_lock
);
730 static int ip4ip6_rcv(struct sk_buff
*skb
)
732 return ip6_tnl_rcv(skb
, ETH_P_IP
, IPPROTO_IPIP
,
733 ip4ip6_dscp_ecn_decapsulate
);
736 static int ip6ip6_rcv(struct sk_buff
*skb
)
738 return ip6_tnl_rcv(skb
, ETH_P_IPV6
, IPPROTO_IPV6
,
739 ip6ip6_dscp_ecn_decapsulate
);
742 struct ipv6_tel_txoption
{
743 struct ipv6_txoptions ops
;
747 static void init_tel_txopt(struct ipv6_tel_txoption
*opt
, __u8 encap_limit
)
749 memset(opt
, 0, sizeof(struct ipv6_tel_txoption
));
751 opt
->dst_opt
[2] = IPV6_TLV_TNL_ENCAP_LIMIT
;
753 opt
->dst_opt
[4] = encap_limit
;
754 opt
->dst_opt
[5] = IPV6_TLV_PADN
;
757 opt
->ops
.dst0opt
= (struct ipv6_opt_hdr
*) opt
->dst_opt
;
758 opt
->ops
.opt_nflen
= 8;
762 * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
763 * @t: the outgoing tunnel device
764 * @hdr: IPv6 header from the incoming packet
767 * Avoid trivial tunneling loop by checking that tunnel exit-point
768 * doesn't match source of incoming packet.
776 ip6_tnl_addr_conflict(struct ip6_tnl
*t
, struct ipv6hdr
*hdr
)
778 return ipv6_addr_equal(&t
->parms
.raddr
, &hdr
->saddr
);
781 static inline int ip6_tnl_xmit_ctl(struct ip6_tnl
*t
)
783 struct ip6_tnl_parm
*p
= &t
->parms
;
786 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
787 struct net_device
*ldev
= NULL
;
790 ldev
= dev_get_by_index(&init_net
, p
->link
);
792 if (unlikely(!ipv6_chk_addr(&init_net
, &p
->laddr
, ldev
, 0)))
794 "%s xmit: Local address not yet configured!\n",
796 else if (!ipv6_addr_is_multicast(&p
->raddr
) &&
797 unlikely(ipv6_chk_addr(&init_net
, &p
->raddr
, NULL
, 0)))
799 "%s xmit: Routing loop! "
800 "Remote address found on this node!\n",
810 * ip6_tnl_xmit2 - encapsulate packet and send
811 * @skb: the outgoing socket buffer
812 * @dev: the outgoing tunnel device
813 * @dsfield: dscp code for outer header
814 * @fl: flow of tunneled packet
815 * @encap_limit: encapsulation limit
816 * @pmtu: Path MTU is stored if packet is too big
819 * Build new header and do some sanity checks on the packet before sending
825 * %-EMSGSIZE message too big. return mtu in this case.
828 static int ip6_tnl_xmit2(struct sk_buff
*skb
,
829 struct net_device
*dev
,
835 struct ip6_tnl
*t
= netdev_priv(dev
);
836 struct net_device_stats
*stats
= &t
->stat
;
837 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
838 struct ipv6_tel_txoption opt
;
839 struct dst_entry
*dst
;
840 struct net_device
*tdev
;
842 unsigned int max_headroom
= sizeof(struct ipv6hdr
);
847 if ((dst
= ip6_tnl_dst_check(t
)) != NULL
)
850 dst
= ip6_route_output(&init_net
, NULL
, fl
);
852 if (dst
->error
|| xfrm_lookup(&dst
, fl
, NULL
, 0) < 0)
853 goto tx_err_link_failure
;
862 "%s: Local routing loop detected!\n",
864 goto tx_err_dst_release
;
866 mtu
= dst_mtu(dst
) - sizeof (*ipv6h
);
867 if (encap_limit
>= 0) {
871 if (mtu
< IPV6_MIN_MTU
)
874 skb
->dst
->ops
->update_pmtu(skb
->dst
, mtu
);
875 if (skb
->len
> mtu
) {
878 goto tx_err_dst_release
;
882 * Okay, now see if we can stuff it in the buffer as-is.
884 max_headroom
+= LL_RESERVED_SPACE(tdev
);
886 if (skb_headroom(skb
) < max_headroom
|| skb_shared(skb
) ||
887 (skb_cloned(skb
) && !skb_clone_writable(skb
, 0))) {
888 struct sk_buff
*new_skb
;
890 if (!(new_skb
= skb_realloc_headroom(skb
, max_headroom
)))
891 goto tx_err_dst_release
;
894 skb_set_owner_w(new_skb
, skb
->sk
);
898 dst_release(skb
->dst
);
899 skb
->dst
= dst_clone(dst
);
901 skb
->transport_header
= skb
->network_header
;
904 if (encap_limit
>= 0) {
905 init_tel_txopt(&opt
, encap_limit
);
906 ipv6_push_nfrag_opts(skb
, &opt
.ops
, &proto
, NULL
);
908 skb_push(skb
, sizeof(struct ipv6hdr
));
909 skb_reset_network_header(skb
);
910 ipv6h
= ipv6_hdr(skb
);
911 *(__be32
*)ipv6h
= fl
->fl6_flowlabel
| htonl(0x60000000);
912 dsfield
= INET_ECN_encapsulate(0, dsfield
);
913 ipv6_change_dsfield(ipv6h
, ~INET_ECN_MASK
, dsfield
);
914 ipv6h
->hop_limit
= t
->parms
.hop_limit
;
915 ipv6h
->nexthdr
= proto
;
916 ipv6_addr_copy(&ipv6h
->saddr
, &fl
->fl6_src
);
917 ipv6_addr_copy(&ipv6h
->daddr
, &fl
->fl6_dst
);
920 err
= ip6_local_out(skb
);
922 if (net_xmit_eval(err
) == 0) {
923 stats
->tx_bytes
+= pkt_len
;
927 stats
->tx_aborted_errors
++;
929 ip6_tnl_dst_store(t
, dst
);
932 stats
->tx_carrier_errors
++;
933 dst_link_failure(skb
);
940 ip4ip6_tnl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
942 struct ip6_tnl
*t
= netdev_priv(dev
);
943 struct iphdr
*iph
= ip_hdr(skb
);
944 int encap_limit
= -1;
950 if ((t
->parms
.proto
!= IPPROTO_IPIP
&& t
->parms
.proto
!= 0) ||
951 !ip6_tnl_xmit_ctl(t
))
954 if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
955 encap_limit
= t
->parms
.encap_limit
;
957 memcpy(&fl
, &t
->fl
, sizeof (fl
));
958 fl
.proto
= IPPROTO_IPIP
;
960 dsfield
= ipv4_get_dsfield(iph
);
962 if ((t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
))
963 fl
.fl6_flowlabel
|= htonl((__u32
)iph
->tos
<< IPV6_TCLASS_SHIFT
)
966 err
= ip6_tnl_xmit2(skb
, dev
, dsfield
, &fl
, encap_limit
, &mtu
);
968 /* XXX: send ICMP error even if DF is not set. */
969 if (err
== -EMSGSIZE
)
970 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_FRAG_NEEDED
,
979 ip6ip6_tnl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
981 struct ip6_tnl
*t
= netdev_priv(dev
);
982 struct ipv6hdr
*ipv6h
= ipv6_hdr(skb
);
983 int encap_limit
= -1;
990 if ((t
->parms
.proto
!= IPPROTO_IPV6
&& t
->parms
.proto
!= 0) ||
991 !ip6_tnl_xmit_ctl(t
) || ip6_tnl_addr_conflict(t
, ipv6h
))
994 offset
= parse_tlv_tnl_enc_lim(skb
, skb_network_header(skb
));
996 struct ipv6_tlv_tnl_enc_lim
*tel
;
997 tel
= (struct ipv6_tlv_tnl_enc_lim
*)&skb_network_header(skb
)[offset
];
998 if (tel
->encap_limit
== 0) {
999 icmpv6_send(skb
, ICMPV6_PARAMPROB
,
1000 ICMPV6_HDR_FIELD
, offset
+ 2, skb
->dev
);
1003 encap_limit
= tel
->encap_limit
- 1;
1004 } else if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
))
1005 encap_limit
= t
->parms
.encap_limit
;
1007 memcpy(&fl
, &t
->fl
, sizeof (fl
));
1008 fl
.proto
= IPPROTO_IPV6
;
1010 dsfield
= ipv6_get_dsfield(ipv6h
);
1011 if ((t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
))
1012 fl
.fl6_flowlabel
|= (*(__be32
*) ipv6h
& IPV6_TCLASS_MASK
);
1013 if ((t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FLOWLABEL
))
1014 fl
.fl6_flowlabel
|= (*(__be32
*) ipv6h
& IPV6_FLOWLABEL_MASK
);
1016 err
= ip6_tnl_xmit2(skb
, dev
, dsfield
, &fl
, encap_limit
, &mtu
);
1018 if (err
== -EMSGSIZE
)
1019 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
, dev
);
1027 ip6_tnl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1029 struct ip6_tnl
*t
= netdev_priv(dev
);
1030 struct net_device_stats
*stats
= &t
->stat
;
1033 if (t
->recursion
++) {
1034 t
->stat
.collisions
++;
1038 switch (skb
->protocol
) {
1039 case __constant_htons(ETH_P_IP
):
1040 ret
= ip4ip6_tnl_xmit(skb
, dev
);
1042 case __constant_htons(ETH_P_IPV6
):
1043 ret
= ip6ip6_tnl_xmit(skb
, dev
);
1057 stats
->tx_dropped
++;
1063 static void ip6_tnl_set_cap(struct ip6_tnl
*t
)
1065 struct ip6_tnl_parm
*p
= &t
->parms
;
1066 int ltype
= ipv6_addr_type(&p
->laddr
);
1067 int rtype
= ipv6_addr_type(&p
->raddr
);
1069 p
->flags
&= ~(IP6_TNL_F_CAP_XMIT
|IP6_TNL_F_CAP_RCV
);
1071 if (ltype
& (IPV6_ADDR_UNICAST
|IPV6_ADDR_MULTICAST
) &&
1072 rtype
& (IPV6_ADDR_UNICAST
|IPV6_ADDR_MULTICAST
) &&
1073 !((ltype
|rtype
) & IPV6_ADDR_LOOPBACK
) &&
1074 (!((ltype
|rtype
) & IPV6_ADDR_LINKLOCAL
) || p
->link
)) {
1075 if (ltype
&IPV6_ADDR_UNICAST
)
1076 p
->flags
|= IP6_TNL_F_CAP_XMIT
;
1077 if (rtype
&IPV6_ADDR_UNICAST
)
1078 p
->flags
|= IP6_TNL_F_CAP_RCV
;
1082 static void ip6_tnl_link_config(struct ip6_tnl
*t
)
1084 struct net_device
*dev
= t
->dev
;
1085 struct ip6_tnl_parm
*p
= &t
->parms
;
1086 struct flowi
*fl
= &t
->fl
;
1088 memcpy(&dev
->dev_addr
, &p
->laddr
, sizeof(struct in6_addr
));
1089 memcpy(&dev
->broadcast
, &p
->raddr
, sizeof(struct in6_addr
));
1091 /* Set up flowi template */
1092 ipv6_addr_copy(&fl
->fl6_src
, &p
->laddr
);
1093 ipv6_addr_copy(&fl
->fl6_dst
, &p
->raddr
);
1095 fl
->fl6_flowlabel
= 0;
1097 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_TCLASS
))
1098 fl
->fl6_flowlabel
|= IPV6_TCLASS_MASK
& p
->flowinfo
;
1099 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_FLOWLABEL
))
1100 fl
->fl6_flowlabel
|= IPV6_FLOWLABEL_MASK
& p
->flowinfo
;
1104 if (p
->flags
&IP6_TNL_F_CAP_XMIT
&& p
->flags
&IP6_TNL_F_CAP_RCV
)
1105 dev
->flags
|= IFF_POINTOPOINT
;
1107 dev
->flags
&= ~IFF_POINTOPOINT
;
1109 dev
->iflink
= p
->link
;
1111 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
1112 int strict
= (ipv6_addr_type(&p
->raddr
) &
1113 (IPV6_ADDR_MULTICAST
|IPV6_ADDR_LINKLOCAL
));
1115 struct rt6_info
*rt
= rt6_lookup(&init_net
, &p
->raddr
, &p
->laddr
,
1122 dev
->hard_header_len
= rt
->rt6i_dev
->hard_header_len
+
1123 sizeof (struct ipv6hdr
);
1125 dev
->mtu
= rt
->rt6i_dev
->mtu
- sizeof (struct ipv6hdr
);
1127 if (dev
->mtu
< IPV6_MIN_MTU
)
1128 dev
->mtu
= IPV6_MIN_MTU
;
1130 dst_release(&rt
->u
.dst
);
1135 * ip6_tnl_change - update the tunnel parameters
1136 * @t: tunnel to be changed
1137 * @p: tunnel configuration parameters
1138 * @active: != 0 if tunnel is ready for use
1141 * ip6_tnl_change() updates the tunnel parameters
1145 ip6_tnl_change(struct ip6_tnl
*t
, struct ip6_tnl_parm
*p
)
1147 ipv6_addr_copy(&t
->parms
.laddr
, &p
->laddr
);
1148 ipv6_addr_copy(&t
->parms
.raddr
, &p
->raddr
);
1149 t
->parms
.flags
= p
->flags
;
1150 t
->parms
.hop_limit
= p
->hop_limit
;
1151 t
->parms
.encap_limit
= p
->encap_limit
;
1152 t
->parms
.flowinfo
= p
->flowinfo
;
1153 t
->parms
.link
= p
->link
;
1154 t
->parms
.proto
= p
->proto
;
1155 ip6_tnl_dst_reset(t
);
1156 ip6_tnl_link_config(t
);
1161 * ip6_tnl_ioctl - configure ipv6 tunnels from userspace
1162 * @dev: virtual device associated with tunnel
1163 * @ifr: parameters passed from userspace
1164 * @cmd: command to be performed
1167 * ip6_tnl_ioctl() is used for managing IPv6 tunnels
1170 * The possible commands are the following:
1171 * %SIOCGETTUNNEL: get tunnel parameters for device
1172 * %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
1173 * %SIOCCHGTUNNEL: change tunnel parameters to those given
1174 * %SIOCDELTUNNEL: delete tunnel
1176 * The fallback device "ip6tnl0", created during module
1177 * initialization, can be used for creating other tunnel devices.
1181 * %-EFAULT if unable to copy data to or from userspace,
1182 * %-EPERM if current process hasn't %CAP_NET_ADMIN set
1183 * %-EINVAL if passed tunnel parameters are invalid,
1184 * %-EEXIST if changing a tunnel's parameters would cause a conflict
1185 * %-ENODEV if attempting to change or delete a nonexisting device
1189 ip6_tnl_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1192 struct ip6_tnl_parm p
;
1193 struct ip6_tnl
*t
= NULL
;
1197 if (dev
== ip6_fb_tnl_dev
) {
1198 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof (p
))) {
1202 t
= ip6_tnl_locate(&p
, 0);
1205 t
= netdev_priv(dev
);
1206 memcpy(&p
, &t
->parms
, sizeof (p
));
1207 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof (p
))) {
1214 if (!capable(CAP_NET_ADMIN
))
1217 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof (p
)))
1220 if (p
.proto
!= IPPROTO_IPV6
&& p
.proto
!= IPPROTO_IPIP
&&
1223 t
= ip6_tnl_locate(&p
, cmd
== SIOCADDTUNNEL
);
1224 if (dev
!= ip6_fb_tnl_dev
&& cmd
== SIOCCHGTUNNEL
) {
1226 if (t
->dev
!= dev
) {
1231 t
= netdev_priv(dev
);
1234 err
= ip6_tnl_change(t
, &p
);
1236 netdev_state_change(dev
);
1240 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &t
->parms
, sizeof (p
)))
1244 err
= (cmd
== SIOCADDTUNNEL
? -ENOBUFS
: -ENOENT
);
1248 if (!capable(CAP_NET_ADMIN
))
1251 if (dev
== ip6_fb_tnl_dev
) {
1253 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof (p
)))
1256 if ((t
= ip6_tnl_locate(&p
, 0)) == NULL
)
1259 if (t
->dev
== ip6_fb_tnl_dev
)
1264 unregister_netdevice(dev
);
1273 * ip6_tnl_get_stats - return the stats for tunnel device
1274 * @dev: virtual device associated with tunnel
1276 * Return: stats for device
1279 static struct net_device_stats
*
1280 ip6_tnl_get_stats(struct net_device
*dev
)
1282 return &(((struct ip6_tnl
*)netdev_priv(dev
))->stat
);
1286 * ip6_tnl_change_mtu - change mtu manually for tunnel device
1287 * @dev: virtual device associated with tunnel
1288 * @new_mtu: the new mtu
1292 * %-EINVAL if mtu too small
1296 ip6_tnl_change_mtu(struct net_device
*dev
, int new_mtu
)
1298 if (new_mtu
< IPV6_MIN_MTU
) {
1306 * ip6_tnl_dev_setup - setup virtual tunnel device
1307 * @dev: virtual device associated with tunnel
1310 * Initialize function pointers and device parameters
1313 static void ip6_tnl_dev_setup(struct net_device
*dev
)
1315 dev
->uninit
= ip6_tnl_dev_uninit
;
1316 dev
->destructor
= free_netdev
;
1317 dev
->hard_start_xmit
= ip6_tnl_xmit
;
1318 dev
->get_stats
= ip6_tnl_get_stats
;
1319 dev
->do_ioctl
= ip6_tnl_ioctl
;
1320 dev
->change_mtu
= ip6_tnl_change_mtu
;
1322 dev
->type
= ARPHRD_TUNNEL6
;
1323 dev
->hard_header_len
= LL_MAX_HEADER
+ sizeof (struct ipv6hdr
);
1324 dev
->mtu
= ETH_DATA_LEN
- sizeof (struct ipv6hdr
);
1325 dev
->flags
|= IFF_NOARP
;
1326 dev
->addr_len
= sizeof(struct in6_addr
);
1331 * ip6_tnl_dev_init_gen - general initializer for all tunnel devices
1332 * @dev: virtual device associated with tunnel
1336 ip6_tnl_dev_init_gen(struct net_device
*dev
)
1338 struct ip6_tnl
*t
= netdev_priv(dev
);
1340 strcpy(t
->parms
.name
, dev
->name
);
1344 * ip6_tnl_dev_init - initializer for all non fallback tunnel devices
1345 * @dev: virtual device associated with tunnel
1349 ip6_tnl_dev_init(struct net_device
*dev
)
1351 struct ip6_tnl
*t
= netdev_priv(dev
);
1352 ip6_tnl_dev_init_gen(dev
);
1353 ip6_tnl_link_config(t
);
1358 * ip6_fb_tnl_dev_init - initializer for fallback tunnel device
1359 * @dev: fallback device
1365 ip6_fb_tnl_dev_init(struct net_device
*dev
)
1367 struct ip6_tnl
*t
= netdev_priv(dev
);
1368 ip6_tnl_dev_init_gen(dev
);
1369 t
->parms
.proto
= IPPROTO_IPV6
;
1375 static struct xfrm6_tunnel ip4ip6_handler
= {
1376 .handler
= ip4ip6_rcv
,
1377 .err_handler
= ip4ip6_err
,
1381 static struct xfrm6_tunnel ip6ip6_handler
= {
1382 .handler
= ip6ip6_rcv
,
1383 .err_handler
= ip6ip6_err
,
1388 * ip6_tunnel_init - register protocol and reserve needed resources
1390 * Return: 0 on success
1393 static int __init
ip6_tunnel_init(void)
1397 if (xfrm6_tunnel_register(&ip4ip6_handler
, AF_INET
)) {
1398 printk(KERN_ERR
"ip6_tunnel init: can't register ip4ip6\n");
1403 if (xfrm6_tunnel_register(&ip6ip6_handler
, AF_INET6
)) {
1404 printk(KERN_ERR
"ip6_tunnel init: can't register ip6ip6\n");
1408 ip6_fb_tnl_dev
= alloc_netdev(sizeof(struct ip6_tnl
), "ip6tnl0",
1411 if (!ip6_fb_tnl_dev
) {
1415 ip6_fb_tnl_dev
->init
= ip6_fb_tnl_dev_init
;
1417 if ((err
= register_netdev(ip6_fb_tnl_dev
))) {
1418 free_netdev(ip6_fb_tnl_dev
);
1423 xfrm6_tunnel_deregister(&ip6ip6_handler
, AF_INET6
);
1425 xfrm6_tunnel_deregister(&ip4ip6_handler
, AF_INET
);
1430 static void __exit
ip6_tnl_destroy_tunnels(void)
1435 for (h
= 0; h
< HASH_SIZE
; h
++) {
1436 while ((t
= tnls_r_l
[h
]) != NULL
)
1437 unregister_netdevice(t
->dev
);
1441 unregister_netdevice(t
->dev
);
1445 * ip6_tunnel_cleanup - free resources and unregister protocol
1448 static void __exit
ip6_tunnel_cleanup(void)
1450 if (xfrm6_tunnel_deregister(&ip4ip6_handler
, AF_INET
))
1451 printk(KERN_INFO
"ip6_tunnel close: can't deregister ip4ip6\n");
1453 if (xfrm6_tunnel_deregister(&ip6ip6_handler
, AF_INET6
))
1454 printk(KERN_INFO
"ip6_tunnel close: can't deregister ip6ip6\n");
1457 ip6_tnl_destroy_tunnels();
1461 module_init(ip6_tunnel_init
);
1462 module_exit(ip6_tunnel_cleanup
);