2 * IPv6 over IPv6 tunnel device
3 * Linux INET6 implementation
6 * Ville Nuorvala <vnuorval@tcs.hut.fi>
11 * linux/net/ipv6/sit.c
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
22 #include <linux/config.h>
23 #include <linux/module.h>
24 #include <linux/errno.h>
25 #include <linux/types.h>
26 #include <linux/sockios.h>
30 #include <linux/if_tunnel.h>
31 #include <linux/net.h>
32 #include <linux/in6.h>
33 #include <linux/netdevice.h>
34 #include <linux/if_arp.h>
35 #include <linux/icmpv6.h>
36 #include <linux/init.h>
37 #include <linux/route.h>
38 #include <linux/rtnetlink.h>
39 #include <linux/netfilter_ipv6.h>
41 #include <asm/uaccess.h>
42 #include <asm/atomic.h>
46 #include <net/protocol.h>
47 #include <net/ip6_route.h>
48 #include <net/addrconf.h>
49 #include <net/ip6_tunnel.h>
51 #include <net/dsfield.h>
52 #include <net/inet_ecn.h>
54 MODULE_AUTHOR("Ville Nuorvala");
55 MODULE_DESCRIPTION("IPv6-in-IPv6 tunnel");
56 MODULE_LICENSE("GPL");
58 #define IPV6_TLV_TEL_DST_SIZE 8
61 #define IP6_TNL_TRACE(x...) printk(KERN_DEBUG "%s:" x "\n", __FUNCTION__)
63 #define IP6_TNL_TRACE(x...) do {;} while(0)
66 #define IPV6_TCLASS_MASK (IPV6_FLOWINFO_MASK & ~IPV6_FLOWLABEL_MASK)
70 #define HASH(addr) (((addr)->s6_addr32[0] ^ (addr)->s6_addr32[1] ^ \
71 (addr)->s6_addr32[2] ^ (addr)->s6_addr32[3]) & \
74 static int ip6ip6_fb_tnl_dev_init(struct net_device
*dev
);
75 static int ip6ip6_tnl_dev_init(struct net_device
*dev
);
76 static void ip6ip6_tnl_dev_setup(struct net_device
*dev
);
78 /* the IPv6 tunnel fallback device */
79 static struct net_device
*ip6ip6_fb_tnl_dev
;
82 /* lists for storing tunnels in use */
83 static struct ip6_tnl
*tnls_r_l
[HASH_SIZE
];
84 static struct ip6_tnl
*tnls_wc
[1];
85 static struct ip6_tnl
**tnls
[2] = { tnls_wc
, tnls_r_l
};
87 /* lock for the tunnel lists */
88 static rwlock_t ip6ip6_lock
= RW_LOCK_UNLOCKED
;
90 static inline struct dst_entry
*ip6_tnl_dst_check(struct ip6_tnl
*t
)
92 struct dst_entry
*dst
= t
->dst_cache
;
94 if (dst
&& dst
->obsolete
&&
95 dst
->ops
->check(dst
, t
->dst_cookie
) == NULL
) {
103 static inline void ip6_tnl_dst_reset(struct ip6_tnl
*t
)
105 dst_release(t
->dst_cache
);
109 static inline void ip6_tnl_dst_store(struct ip6_tnl
*t
, struct dst_entry
*dst
)
111 struct rt6_info
*rt
= (struct rt6_info
*) dst
;
112 t
->dst_cookie
= rt
->rt6i_node
? rt
->rt6i_node
->fn_sernum
: 0;
113 dst_release(t
->dst_cache
);
118 * ip6ip6_tnl_lookup - fetch tunnel matching the end-point addresses
119 * @remote: the address of the tunnel exit-point
120 * @local: the address of the tunnel entry-point
123 * tunnel matching given end-points if found,
124 * else fallback tunnel if its device is up,
128 static struct ip6_tnl
*
129 ip6ip6_tnl_lookup(struct in6_addr
*remote
, struct in6_addr
*local
)
131 unsigned h0
= HASH(remote
);
132 unsigned h1
= HASH(local
);
135 for (t
= tnls_r_l
[h0
^ h1
]; t
; t
= t
->next
) {
136 if (!ipv6_addr_cmp(local
, &t
->parms
.laddr
) &&
137 !ipv6_addr_cmp(remote
, &t
->parms
.raddr
) &&
138 (t
->dev
->flags
& IFF_UP
))
141 if ((t
= tnls_wc
[0]) != NULL
&& (t
->dev
->flags
& IFF_UP
))
148 * ip6ip6_bucket - get head of list matching given tunnel parameters
149 * @p: parameters containing tunnel end-points
152 * ip6ip6_bucket() returns the head of the list matching the
153 * &struct in6_addr entries laddr and raddr in @p.
155 * Return: head of IPv6 tunnel list
158 static struct ip6_tnl
**
159 ip6ip6_bucket(struct ip6_tnl_parm
*p
)
161 struct in6_addr
*remote
= &p
->raddr
;
162 struct in6_addr
*local
= &p
->laddr
;
166 if (!ipv6_addr_any(remote
) || !ipv6_addr_any(local
)) {
168 h
= HASH(remote
) ^ HASH(local
);
170 return &tnls
[prio
][h
];
174 * ip6ip6_tnl_link - add tunnel to hash table
175 * @t: tunnel to be added
179 ip6ip6_tnl_link(struct ip6_tnl
*t
)
181 struct ip6_tnl
**tp
= ip6ip6_bucket(&t
->parms
);
183 write_lock_bh(&ip6ip6_lock
);
185 write_unlock_bh(&ip6ip6_lock
);
190 * ip6ip6_tnl_unlink - remove tunnel from hash table
191 * @t: tunnel to be removed
195 ip6ip6_tnl_unlink(struct ip6_tnl
*t
)
199 for (tp
= ip6ip6_bucket(&t
->parms
); *tp
; tp
= &(*tp
)->next
) {
201 write_lock_bh(&ip6ip6_lock
);
203 write_unlock_bh(&ip6ip6_lock
);
210 * ip6_tnl_create() - create a new tunnel
211 * @p: tunnel parameters
212 * @pt: pointer to new tunnel
215 * Create tunnel matching given parameters.
222 ip6_tnl_create(struct ip6_tnl_parm
*p
, struct ip6_tnl
**pt
)
224 struct net_device
*dev
;
230 strlcpy(name
, p
->name
, IFNAMSIZ
);
233 for (i
= 1; i
< IP6_TNL_MAX
; i
++) {
234 sprintf(name
, "ip6tnl%d", i
);
235 if (__dev_get_by_name(name
) == NULL
)
238 if (i
== IP6_TNL_MAX
)
241 dev
= alloc_netdev(sizeof (*t
), name
, ip6ip6_tnl_dev_setup
);
246 dev
->init
= ip6ip6_tnl_dev_init
;
249 if ((err
= register_netdevice(dev
)) < 0) {
261 * ip6ip6_tnl_locate - find or create tunnel matching given parameters
262 * @p: tunnel parameters
263 * @create: != 0 if allowed to create new tunnel if no match found
266 * ip6ip6_tnl_locate() first tries to locate an existing tunnel
267 * based on @parms. If this is unsuccessful, but @create is set a new
268 * tunnel device is created and registered for use.
271 * 0 if tunnel located or created,
272 * -EINVAL if parameters incorrect,
273 * -ENODEV if no matching tunnel available
277 ip6ip6_tnl_locate(struct ip6_tnl_parm
*p
, struct ip6_tnl
**pt
, int create
)
279 struct in6_addr
*remote
= &p
->raddr
;
280 struct in6_addr
*local
= &p
->laddr
;
283 if (p
->proto
!= IPPROTO_IPV6
)
286 for (t
= *ip6ip6_bucket(p
); t
; t
= t
->next
) {
287 if (!ipv6_addr_cmp(local
, &t
->parms
.laddr
) &&
288 !ipv6_addr_cmp(remote
, &t
->parms
.raddr
)) {
290 return (create
? -EEXIST
: 0);
296 return ip6_tnl_create(p
, pt
);
300 * ip6ip6_tnl_dev_uninit - tunnel device uninitializer
301 * @dev: the device to be destroyed
304 * ip6ip6_tnl_dev_uninit() removes tunnel from its list
308 ip6ip6_tnl_dev_uninit(struct net_device
*dev
)
310 struct ip6_tnl
*t
= dev
->priv
;
312 if (dev
== ip6ip6_fb_tnl_dev
) {
313 write_lock_bh(&ip6ip6_lock
);
315 write_unlock_bh(&ip6ip6_lock
);
317 ip6ip6_tnl_unlink(t
);
319 ip6_tnl_dst_reset(t
);
324 * parse_tvl_tnl_enc_lim - handle encapsulation limit option
325 * @skb: received socket buffer
328 * 0 if none was found,
329 * else index to encapsulation limit
333 parse_tlv_tnl_enc_lim(struct sk_buff
*skb
, __u8
* raw
)
335 struct ipv6hdr
*ipv6h
= (struct ipv6hdr
*) raw
;
336 __u8 nexthdr
= ipv6h
->nexthdr
;
337 __u16 off
= sizeof (*ipv6h
);
339 while (ipv6_ext_hdr(nexthdr
) && nexthdr
!= NEXTHDR_NONE
) {
341 struct ipv6_opt_hdr
*hdr
;
342 if (raw
+ off
+ sizeof (*hdr
) > skb
->data
&&
343 !pskb_may_pull(skb
, raw
- skb
->data
+ off
+ sizeof (*hdr
)))
346 hdr
= (struct ipv6_opt_hdr
*) (raw
+ off
);
347 if (nexthdr
== NEXTHDR_FRAGMENT
) {
348 struct frag_hdr
*frag_hdr
= (struct frag_hdr
*) hdr
;
349 if (frag_hdr
->frag_off
)
352 } else if (nexthdr
== NEXTHDR_AUTH
) {
353 optlen
= (hdr
->hdrlen
+ 2) << 2;
355 optlen
= ipv6_optlen(hdr
);
357 if (nexthdr
== NEXTHDR_DEST
) {
360 struct ipv6_tlv_tnl_enc_lim
*tel
;
362 /* No more room for encapsulation limit */
363 if (i
+ sizeof (*tel
) > off
+ optlen
)
366 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &raw
[i
];
367 /* return index of option if found and valid */
368 if (tel
->type
== IPV6_TLV_TNL_ENCAP_LIMIT
&&
371 /* else jump to next option */
373 i
+= tel
->length
+ 2;
378 nexthdr
= hdr
->nexthdr
;
385 * ip6ip6_err - tunnel error handler
388 * ip6ip6_err() should handle errors in the tunnel according
389 * to the specifications in RFC 2473.
393 ip6ip6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
394 int type
, int code
, int offset
, __u32 info
)
396 struct ipv6hdr
*ipv6h
= (struct ipv6hdr
*) skb
->data
;
399 int rel_type
= ICMPV6_DEST_UNREACH
;
400 int rel_code
= ICMPV6_ADDR_UNREACH
;
404 /* If the packet doesn't contain the original IPv6 header we are
405 in trouble since we might need the source address for further
406 processing of the error. */
408 read_lock(&ip6ip6_lock
);
409 if ((t
= ip6ip6_tnl_lookup(&ipv6h
->daddr
, &ipv6h
->saddr
)) == NULL
)
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
:
434 /* ignore if parameter problem not caused by a tunnel
435 encapsulation limit sub-option */
436 if (code
!= ICMPV6_HDR_FIELD
) {
439 teli
= parse_tlv_tnl_enc_lim(skb
, skb
->data
);
441 if (teli
&& teli
== ntohl(info
) - 2) {
442 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &skb
->data
[teli
];
443 if (tel
->encap_limit
== 0) {
446 "%s: Too small encapsulation "
447 "limit or routing loop in "
448 "tunnel!\n", t
->parms
.name
);
453 case ICMPV6_PKT_TOOBIG
:
454 mtu
= ntohl(info
) - offset
;
455 if (mtu
< IPV6_MIN_MTU
)
459 if ((len
= sizeof (*ipv6h
) + ipv6h
->payload_len
) > mtu
) {
460 rel_type
= ICMPV6_PKT_TOOBIG
;
467 if (rel_msg
&& pskb_may_pull(skb
, offset
+ sizeof (*ipv6h
))) {
469 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
473 dst_release(skb2
->dst
);
475 skb_pull(skb2
, offset
);
476 skb2
->nh
.raw
= skb2
->data
;
478 /* Try to guess incoming interface */
479 rt
= rt6_lookup(&skb2
->nh
.ipv6h
->saddr
, NULL
, 0, 0);
481 if (rt
&& rt
->rt6i_dev
)
482 skb2
->dev
= rt
->rt6i_dev
;
484 icmpv6_send(skb2
, rel_type
, rel_code
, rel_info
, skb2
->dev
);
487 dst_release(&rt
->u
.dst
);
492 read_unlock(&ip6ip6_lock
);
495 static inline void ip6ip6_ecn_decapsulate(struct ipv6hdr
*outer_iph
,
498 struct ipv6hdr
*inner_iph
= skb
->nh
.ipv6h
;
500 if (INET_ECN_is_ce(ipv6_get_dsfield(outer_iph
)))
501 IP6_ECN_set_ce(inner_iph
);
505 * ip6ip6_rcv - decapsulate IPv6 packet and retransmit it locally
506 * @skb: received socket buffer
512 ip6ip6_rcv(struct sk_buff
**pskb
, unsigned int *nhoffp
)
514 struct sk_buff
*skb
= *pskb
;
515 struct ipv6hdr
*ipv6h
;
518 if (!pskb_may_pull(skb
, sizeof (*ipv6h
)))
521 ipv6h
= skb
->nh
.ipv6h
;
523 read_lock(&ip6ip6_lock
);
525 if ((t
= ip6ip6_tnl_lookup(&ipv6h
->saddr
, &ipv6h
->daddr
)) != NULL
) {
526 if (!xfrm6_policy_check(NULL
, XFRM_POLICY_IN
, skb
)) {
531 if (!(t
->parms
.flags
& IP6_TNL_F_CAP_RCV
)) {
532 t
->stat
.rx_dropped
++;
533 read_unlock(&ip6ip6_lock
);
537 skb
->mac
.raw
= skb
->nh
.raw
;
538 skb
->nh
.raw
= skb
->data
;
539 skb
->protocol
= htons(ETH_P_IPV6
);
540 skb
->pkt_type
= PACKET_HOST
;
541 memset(skb
->cb
, 0, sizeof(struct inet6_skb_parm
));
543 dst_release(skb
->dst
);
545 if (t
->parms
.flags
& IP6_TNL_F_RCV_DSCP_COPY
)
546 ipv6_copy_dscp(ipv6h
, skb
->nh
.ipv6h
);
547 ip6ip6_ecn_decapsulate(ipv6h
, skb
);
548 t
->stat
.rx_packets
++;
549 t
->stat
.rx_bytes
+= skb
->len
;
551 read_unlock(&ip6ip6_lock
);
554 read_unlock(&ip6ip6_lock
);
555 icmpv6_send(skb
, ICMPV6_DEST_UNREACH
, ICMPV6_ADDR_UNREACH
, 0, skb
->dev
);
560 static inline struct ipv6_txoptions
*create_tel(__u8 encap_limit
)
562 struct ipv6_tlv_tnl_enc_lim
*tel
;
563 struct ipv6_txoptions
*opt
;
566 int opt_len
= sizeof(*opt
) + 8;
568 if (!(opt
= kmalloc(opt_len
, GFP_ATOMIC
))) {
571 memset(opt
, 0, opt_len
);
572 opt
->tot_len
= opt_len
;
573 opt
->dst0opt
= (struct ipv6_opt_hdr
*) (opt
+ 1);
576 tel
= (struct ipv6_tlv_tnl_enc_lim
*) (opt
->dst0opt
+ 1);
577 tel
->type
= IPV6_TLV_TNL_ENCAP_LIMIT
;
579 tel
->encap_limit
= encap_limit
;
581 raw
= (__u8
*) opt
->dst0opt
;
582 raw
[5] = IPV6_TLV_PADN
;
589 * ip6ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
590 * @t: the outgoing tunnel device
591 * @hdr: IPv6 header from the incoming packet
594 * Avoid trivial tunneling loop by checking that tunnel exit-point
595 * doesn't match source of incoming packet.
603 ip6ip6_tnl_addr_conflict(struct ip6_tnl
*t
, struct ipv6hdr
*hdr
)
605 return !ipv6_addr_cmp(&t
->parms
.raddr
, &hdr
->saddr
);
609 * ip6ip6_tnl_xmit - encapsulate packet and send
610 * @skb: the outgoing socket buffer
611 * @dev: the outgoing tunnel device
614 * Build new header and do some sanity checks on the packet before sending
622 ip6ip6_tnl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
624 struct ip6_tnl
*t
= (struct ip6_tnl
*) dev
->priv
;
625 struct net_device_stats
*stats
= &t
->stat
;
626 struct ipv6hdr
*ipv6h
= skb
->nh
.ipv6h
;
627 struct ipv6_txoptions
*opt
= NULL
;
628 int encap_limit
= -1;
631 struct dst_entry
*dst
;
632 struct net_device
*tdev
;
634 int max_headroom
= sizeof(struct ipv6hdr
);
640 if (t
->recursion
++) {
644 if (skb
->protocol
!= htons(ETH_P_IPV6
) ||
645 !(t
->parms
.flags
& IP6_TNL_F_CAP_XMIT
) ||
646 ip6ip6_tnl_addr_conflict(t
, ipv6h
)) {
649 if ((offset
= parse_tlv_tnl_enc_lim(skb
, skb
->nh
.raw
)) > 0) {
650 struct ipv6_tlv_tnl_enc_lim
*tel
;
651 tel
= (struct ipv6_tlv_tnl_enc_lim
*) &skb
->nh
.raw
[offset
];
652 if (tel
->encap_limit
== 0) {
653 icmpv6_send(skb
, ICMPV6_PARAMPROB
,
654 ICMPV6_HDR_FIELD
, offset
+ 2, skb
->dev
);
657 encap_limit
= tel
->encap_limit
- 1;
658 } else if (!(t
->parms
.flags
& IP6_TNL_F_IGN_ENCAP_LIMIT
)) {
659 encap_limit
= t
->parms
.encap_limit
;
661 memcpy(&fl
, &t
->fl
, sizeof (fl
));
664 dsfield
= ipv6_get_dsfield(ipv6h
);
665 if ((t
->parms
.flags
& IP6_TNL_F_USE_ORIG_TCLASS
))
666 fl
.fl6_flowlabel
|= (*(__u32
*) ipv6h
& IPV6_TCLASS_MASK
);
667 if ((t
->parms
.flags
& IP6_TNL_F_USE_ORIG_FLOWLABEL
))
668 fl
.fl6_flowlabel
|= (*(__u32
*) ipv6h
& IPV6_FLOWLABEL_MASK
);
670 if (encap_limit
>= 0 && (opt
= create_tel(encap_limit
)) == NULL
)
673 if ((dst
= ip6_tnl_dst_check(t
)) != NULL
)
676 dst
= ip6_route_output(NULL
, &fl
);
678 if (dst
->error
|| xfrm_lookup(&dst
, &fl
, NULL
, 0) < 0)
679 goto tx_err_link_failure
;
687 "%s: Local routing loop detected!\n",
689 goto tx_err_dst_release
;
691 mtu
= dst_pmtu(dst
) - sizeof (*ipv6h
);
696 if (mtu
< IPV6_MIN_MTU
)
698 if (skb
->dst
&& mtu
< dst_pmtu(skb
->dst
)) {
699 struct rt6_info
*rt
= (struct rt6_info
*) skb
->dst
;
700 rt
->rt6i_flags
|= RTF_MODIFIED
;
701 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = mtu
;
703 if (skb
->len
> mtu
) {
704 icmpv6_send(skb
, ICMPV6_PKT_TOOBIG
, 0, mtu
, dev
);
705 goto tx_err_dst_release
;
709 * Okay, now see if we can stuff it in the buffer as-is.
711 max_headroom
+= LL_RESERVED_SPACE(tdev
);
713 if (skb_headroom(skb
) < max_headroom
||
714 skb_cloned(skb
) || skb_shared(skb
)) {
715 struct sk_buff
*new_skb
;
717 if (!(new_skb
= skb_realloc_headroom(skb
, max_headroom
)))
718 goto tx_err_dst_release
;
721 skb_set_owner_w(new_skb
, skb
->sk
);
725 dst_release(skb
->dst
);
726 skb
->dst
= dst_clone(dst
);
728 skb
->h
.raw
= skb
->nh
.raw
;
731 ipv6_push_nfrag_opts(skb
, opt
, &proto
, NULL
);
733 skb
->nh
.raw
= skb_push(skb
, sizeof(struct ipv6hdr
));
734 ipv6h
= skb
->nh
.ipv6h
;
735 *(u32
*)ipv6h
= fl
.fl6_flowlabel
| htonl(0x60000000);
736 dsfield
= INET_ECN_encapsulate(0, dsfield
);
737 ipv6_change_dsfield(ipv6h
, ~INET_ECN_MASK
, dsfield
);
738 ipv6h
->payload_len
= htons(skb
->len
- sizeof(struct ipv6hdr
));
739 ipv6h
->hop_limit
= t
->parms
.hop_limit
;
740 ipv6h
->nexthdr
= proto
;
741 ipv6_addr_copy(&ipv6h
->saddr
, &fl
.fl6_src
);
742 ipv6_addr_copy(&ipv6h
->daddr
, &fl
.fl6_dst
);
745 err
= NF_HOOK(PF_INET6
, NF_IP6_LOCAL_OUT
, skb
, NULL
,
746 skb
->dst
->dev
, dst_output
);
748 if (err
== NET_XMIT_SUCCESS
|| err
== NET_XMIT_CN
) {
749 stats
->tx_bytes
+= pkt_len
;
753 stats
->tx_aborted_errors
++;
755 ip6_tnl_dst_store(t
, dst
);
763 stats
->tx_carrier_errors
++;
764 dst_link_failure(skb
);
777 static void ip6_tnl_set_cap(struct ip6_tnl
*t
)
779 struct ip6_tnl_parm
*p
= &t
->parms
;
780 struct in6_addr
*laddr
= &p
->laddr
;
781 struct in6_addr
*raddr
= &p
->raddr
;
782 int ltype
= ipv6_addr_type(laddr
);
783 int rtype
= ipv6_addr_type(raddr
);
785 p
->flags
&= ~(IP6_TNL_F_CAP_XMIT
|IP6_TNL_F_CAP_RCV
);
787 if (ltype
!= IPV6_ADDR_ANY
&& rtype
!= IPV6_ADDR_ANY
&&
790 IPV6_ADDR_LOOPBACK
|IPV6_ADDR_LINKLOCAL
|
791 IPV6_ADDR_MAPPED
|IPV6_ADDR_RESERVED
)) == IPV6_ADDR_UNICAST
) {
792 struct net_device
*ldev
= NULL
;
797 ldev
= dev_get_by_index(p
->link
);
799 if (ltype
&IPV6_ADDR_UNICAST
&& !ipv6_chk_addr(laddr
, ldev
, 0))
802 if (rtype
&IPV6_ADDR_UNICAST
&& ipv6_chk_addr(raddr
, NULL
, 0))
806 if (ltype
&IPV6_ADDR_UNICAST
)
807 p
->flags
|= IP6_TNL_F_CAP_XMIT
;
808 if (rtype
&IPV6_ADDR_UNICAST
)
809 p
->flags
|= IP6_TNL_F_CAP_RCV
;
816 static void ip6ip6_tnl_link_config(struct ip6_tnl
*t
)
818 struct net_device
*dev
= t
->dev
;
819 struct ip6_tnl_parm
*p
= &t
->parms
;
820 struct flowi
*fl
= &t
->fl
;
822 memcpy(&dev
->dev_addr
, &p
->laddr
, sizeof(struct in6_addr
));
823 memcpy(&dev
->broadcast
, &p
->raddr
, sizeof(struct in6_addr
));
825 /* Set up flowi template */
826 ipv6_addr_copy(&fl
->fl6_src
, &p
->laddr
);
827 ipv6_addr_copy(&fl
->fl6_dst
, &p
->raddr
);
829 fl
->fl6_flowlabel
= 0;
831 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_TCLASS
))
832 fl
->fl6_flowlabel
|= IPV6_TCLASS_MASK
& p
->flowinfo
;
833 if (!(p
->flags
&IP6_TNL_F_USE_ORIG_FLOWLABEL
))
834 fl
->fl6_flowlabel
|= IPV6_FLOWLABEL_MASK
& p
->flowinfo
;
838 if (p
->flags
&IP6_TNL_F_CAP_XMIT
&& p
->flags
&IP6_TNL_F_CAP_RCV
)
839 dev
->flags
|= IFF_POINTOPOINT
;
841 dev
->flags
&= ~IFF_POINTOPOINT
;
843 dev
->iflink
= p
->link
;
845 if (p
->flags
& IP6_TNL_F_CAP_XMIT
) {
846 struct rt6_info
*rt
= rt6_lookup(&p
->raddr
, &p
->laddr
,
853 dev
->hard_header_len
= rt
->rt6i_dev
->hard_header_len
+
854 sizeof (struct ipv6hdr
);
856 dev
->mtu
= rt
->rt6i_dev
->mtu
- sizeof (struct ipv6hdr
);
858 if (dev
->mtu
< IPV6_MIN_MTU
)
859 dev
->mtu
= IPV6_MIN_MTU
;
861 dst_release(&rt
->u
.dst
);
866 * ip6ip6_tnl_change - update the tunnel parameters
867 * @t: tunnel to be changed
868 * @p: tunnel configuration parameters
869 * @active: != 0 if tunnel is ready for use
872 * ip6ip6_tnl_change() updates the tunnel parameters
876 ip6ip6_tnl_change(struct ip6_tnl
*t
, struct ip6_tnl_parm
*p
)
878 ipv6_addr_copy(&t
->parms
.laddr
, &p
->laddr
);
879 ipv6_addr_copy(&t
->parms
.raddr
, &p
->raddr
);
880 t
->parms
.flags
= p
->flags
;
881 t
->parms
.hop_limit
= p
->hop_limit
;
882 t
->parms
.encap_limit
= p
->encap_limit
;
883 t
->parms
.flowinfo
= p
->flowinfo
;
884 ip6ip6_tnl_link_config(t
);
889 * ip6ip6_tnl_ioctl - configure ipv6 tunnels from userspace
890 * @dev: virtual device associated with tunnel
891 * @ifr: parameters passed from userspace
892 * @cmd: command to be performed
895 * ip6ip6_tnl_ioctl() is used for managing IPv6 tunnels
898 * The possible commands are the following:
899 * %SIOCGETTUNNEL: get tunnel parameters for device
900 * %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
901 * %SIOCCHGTUNNEL: change tunnel parameters to those given
902 * %SIOCDELTUNNEL: delete tunnel
904 * The fallback device "ip6tnl0", created during module
905 * initialization, can be used for creating other tunnel devices.
909 * %-EFAULT if unable to copy data to or from userspace,
910 * %-EPERM if current process hasn't %CAP_NET_ADMIN set
911 * %-EINVAL if passed tunnel parameters are invalid,
912 * %-EEXIST if changing a tunnel's parameters would cause a conflict
913 * %-ENODEV if attempting to change or delete a nonexisting device
917 ip6ip6_tnl_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
921 struct ip6_tnl_parm p
;
922 struct ip6_tnl
*t
= NULL
;
926 if (dev
== ip6ip6_fb_tnl_dev
) {
927 if (copy_from_user(&p
,
928 ifr
->ifr_ifru
.ifru_data
,
933 if ((err
= ip6ip6_tnl_locate(&p
, &t
, 0)) == -ENODEV
)
934 t
= (struct ip6_tnl
*) dev
->priv
;
938 t
= (struct ip6_tnl
*) dev
->priv
;
940 memcpy(&p
, &t
->parms
, sizeof (p
));
941 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof (p
))) {
948 create
= (cmd
== SIOCADDTUNNEL
);
949 if (!capable(CAP_NET_ADMIN
))
951 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof (p
))) {
955 if (!create
&& dev
!= ip6ip6_fb_tnl_dev
) {
956 t
= (struct ip6_tnl
*) dev
->priv
;
958 if (!t
&& (err
= ip6ip6_tnl_locate(&p
, &t
, create
))) {
961 if (cmd
== SIOCCHGTUNNEL
) {
966 ip6ip6_tnl_unlink(t
);
967 err
= ip6ip6_tnl_change(t
, &p
);
969 netdev_state_change(dev
);
971 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
,
972 &t
->parms
, sizeof (p
))) {
980 if (!capable(CAP_NET_ADMIN
))
983 if (dev
== ip6ip6_fb_tnl_dev
) {
984 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
,
989 err
= ip6ip6_tnl_locate(&p
, &t
, 0);
992 if (t
== ip6ip6_fb_tnl_dev
->priv
) {
997 t
= (struct ip6_tnl
*) dev
->priv
;
999 err
= unregister_netdevice(t
->dev
);
1008 * ip6ip6_tnl_get_stats - return the stats for tunnel device
1009 * @dev: virtual device associated with tunnel
1011 * Return: stats for device
1014 static struct net_device_stats
*
1015 ip6ip6_tnl_get_stats(struct net_device
*dev
)
1017 return &(((struct ip6_tnl
*) dev
->priv
)->stat
);
1021 * ip6ip6_tnl_change_mtu - change mtu manually for tunnel device
1022 * @dev: virtual device associated with tunnel
1023 * @new_mtu: the new mtu
1027 * %-EINVAL if mtu too small
1031 ip6ip6_tnl_change_mtu(struct net_device
*dev
, int new_mtu
)
1033 if (new_mtu
< IPV6_MIN_MTU
) {
1041 * ip6ip6_tnl_dev_setup - setup virtual tunnel device
1042 * @dev: virtual device associated with tunnel
1045 * Initialize function pointers and device parameters
1048 static void ip6ip6_tnl_dev_setup(struct net_device
*dev
)
1050 SET_MODULE_OWNER(dev
);
1051 dev
->uninit
= ip6ip6_tnl_dev_uninit
;
1052 dev
->destructor
= free_netdev
;
1053 dev
->hard_start_xmit
= ip6ip6_tnl_xmit
;
1054 dev
->get_stats
= ip6ip6_tnl_get_stats
;
1055 dev
->do_ioctl
= ip6ip6_tnl_ioctl
;
1056 dev
->change_mtu
= ip6ip6_tnl_change_mtu
;
1058 dev
->type
= ARPHRD_TUNNEL6
;
1059 dev
->hard_header_len
= LL_MAX_HEADER
+ sizeof (struct ipv6hdr
);
1060 dev
->mtu
= ETH_DATA_LEN
- sizeof (struct ipv6hdr
);
1061 dev
->flags
|= IFF_NOARP
;
1062 dev
->addr_len
= sizeof(struct in6_addr
);
1067 * ip6ip6_tnl_dev_init_gen - general initializer for all tunnel devices
1068 * @dev: virtual device associated with tunnel
1072 ip6ip6_tnl_dev_init_gen(struct net_device
*dev
)
1074 struct ip6_tnl
*t
= (struct ip6_tnl
*) dev
->priv
;
1075 t
->fl
.proto
= IPPROTO_IPV6
;
1077 strcpy(t
->parms
.name
, dev
->name
);
1081 * ip6ip6_tnl_dev_init - initializer for all non fallback tunnel devices
1082 * @dev: virtual device associated with tunnel
1086 ip6ip6_tnl_dev_init(struct net_device
*dev
)
1088 struct ip6_tnl
*t
= (struct ip6_tnl
*) dev
->priv
;
1089 ip6ip6_tnl_dev_init_gen(dev
);
1090 ip6ip6_tnl_link_config(t
);
1095 * ip6ip6_fb_tnl_dev_init - initializer for fallback tunnel device
1096 * @dev: fallback device
1102 ip6ip6_fb_tnl_dev_init(struct net_device
*dev
)
1104 struct ip6_tnl
*t
= dev
->priv
;
1105 ip6ip6_tnl_dev_init_gen(dev
);
1111 static struct xfrm6_tunnel ip6ip6_handler
= {
1112 .handler
= ip6ip6_rcv
,
1113 .err_handler
= ip6ip6_err
,
1117 * ip6_tunnel_init - register protocol and reserve needed resources
1119 * Return: 0 on success
1122 static int __init
ip6_tunnel_init(void)
1126 if (xfrm6_tunnel_register(&ip6ip6_handler
) < 0) {
1127 printk(KERN_ERR
"ip6ip6 init: can't register tunnel\n");
1130 ip6ip6_fb_tnl_dev
= alloc_netdev(sizeof(struct ip6_tnl
), "ip6tnl0",
1131 ip6ip6_tnl_dev_setup
);
1133 if (!ip6ip6_fb_tnl_dev
) {
1137 ip6ip6_fb_tnl_dev
->init
= ip6ip6_fb_tnl_dev_init
;
1139 if ((err
= register_netdev(ip6ip6_fb_tnl_dev
))) {
1140 free_netdev(ip6ip6_fb_tnl_dev
);
1145 xfrm6_tunnel_deregister(&ip6ip6_handler
);
1150 * ip6_tunnel_cleanup - free resources and unregister protocol
1153 static void __exit
ip6_tunnel_cleanup(void)
1155 if (xfrm6_tunnel_deregister(&ip6ip6_handler
) < 0)
1156 printk(KERN_INFO
"ip6ip6 close: can't deregister tunnel\n");
1158 unregister_netdev(ip6ip6_fb_tnl_dev
);
1161 module_init(ip6_tunnel_init
);
1162 module_exit(ip6_tunnel_cleanup
);