2 * Linux NET3: IP/IP protocol decoder.
5 * Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
8 * Alan Cox : Merged and made usable non modular (its so tiny its silly as
9 * a module taking up 2 pages).
10 * Alan Cox : Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph)
11 * to keep ip_forward happy.
12 * Alan Cox : More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8).
13 * Kai Schulte : Fixed #defines for IP_FIREWALL->FIREWALL
14 * David Woodhouse : Perform some basic ICMP handling.
15 * IPIP Routing without decapsulation.
16 * Carlos Picoto : GRE over IP support
17 * Alexey Kuznetsov: Reworked. Really, now it is truncated version of ipv4/ip_gre.c.
18 * I do not want to merge them together.
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
27 /* tunnel.c: an IP tunnel driver
29 The purpose of this driver is to provide an IP tunnel through
30 which you can tunnel network traffic transparently across subnets.
32 This was written by looking at Nick Holloway's dummy driver
33 Thanks for the great code!
35 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
38 Cleaned up the code a little and added some pre-1.3.0 tweaks.
39 dev->hard_header/hard_header_len changed to use no headers.
40 Comments/bracketing tweaked.
41 Made the tunnels use dev->name not tunnel: when error reporting.
44 -Alan Cox (alan@lxorguk.ukuu.org.uk) 21 March 95
47 Changed to tunnel to destination gateway in addition to the
48 tunnel's pointopoint address
49 Almost completely rewritten
50 Note: There is currently no firewall or ICMP handling done.
52 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96
56 /* Things I wish I had known when writing the tunnel driver:
58 When the tunnel_xmit() function is called, the skb contains the
59 packet to be sent (plus a great deal of extra info), and dev
60 contains the tunnel device that _we_ are.
62 When we are passed a packet, we are expected to fill in the
63 source address with our source IP address.
65 What is the proper way to allocate, copy and free a buffer?
66 After you allocate it, it is a "0 length" chunk of memory
67 starting at zero. If you want to add headers to the buffer
68 later, you'll have to call "skb_reserve(skb, amount)" with
69 the amount of memory you want reserved. Then, you call
70 "skb_put(skb, amount)" with the amount of space you want in
71 the buffer. skb_put() returns a pointer to the top (#0) of
72 that buffer. skb->len is set to the amount of space you have
73 "allocated" with skb_put(). You can then write up to skb->len
74 bytes to that buffer. If you need more, you can call skb_put()
75 again with the additional amount of space you need. You can
76 find out how much more space you can allocate by calling
78 Now, to add header space, call "skb_push(skb, header_len)".
79 This creates space at the beginning of the buffer and returns
80 a pointer to this new space. If later you need to strip a
81 header from a buffer, call "skb_pull(skb, header_len)".
82 skb_headroom() will return how much space is left at the top
83 of the buffer (before the main data). Remember, this headroom
84 space must be reserved before the skb_put() function is called.
88 This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
90 For comments look at net/ipv4/ip_gre.c --ANK
94 #include <linux/capability.h>
95 #include <linux/module.h>
96 #include <linux/types.h>
97 #include <linux/kernel.h>
98 #include <linux/slab.h>
99 #include <asm/uaccess.h>
100 #include <linux/skbuff.h>
101 #include <linux/netdevice.h>
102 #include <linux/in.h>
103 #include <linux/tcp.h>
104 #include <linux/udp.h>
105 #include <linux/if_arp.h>
106 #include <linux/mroute.h>
107 #include <linux/init.h>
108 #include <linux/netfilter_ipv4.h>
109 #include <linux/if_ether.h>
111 #include <net/sock.h>
113 #include <net/icmp.h>
114 #include <net/ipip.h>
115 #include <net/inet_ecn.h>
116 #include <net/xfrm.h>
117 #include <net/net_namespace.h>
118 #include <net/netns/generic.h>
121 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
123 static bool log_ecn_error = true;
124 module_param(log_ecn_error, bool, 0644);
125 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
127 static int ipip_net_id __read_mostly;
129 struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
130 struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
131 struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
132 struct ip_tunnel __rcu *tunnels_wc[1];
133 struct ip_tunnel __rcu **tunnels[4];
135 struct net_device *fb_tunnel_dev;
138 static int ipip_tunnel_init(struct net_device *dev);
139 static void ipip_tunnel_setup(struct net_device *dev);
140 static void ipip_dev_free(struct net_device *dev);
141 static struct rtnl_link_ops ipip_link_ops __read_mostly;
143 static struct rtnl_link_stats64 *ipip_get_stats64(struct net_device *dev,
144 struct rtnl_link_stats64 *tot)
148 for_each_possible_cpu(i) {
149 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
150 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
154 start = u64_stats_fetch_begin_bh(&tstats->syncp);
155 rx_packets = tstats->rx_packets;
156 tx_packets = tstats->tx_packets;
157 rx_bytes = tstats->rx_bytes;
158 tx_bytes = tstats->tx_bytes;
159 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
161 tot->rx_packets += rx_packets;
162 tot->tx_packets += tx_packets;
163 tot->rx_bytes += rx_bytes;
164 tot->tx_bytes += tx_bytes;
167 tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
168 tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
169 tot->tx_dropped = dev->stats.tx_dropped;
170 tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
171 tot->tx_errors = dev->stats.tx_errors;
172 tot->collisions = dev->stats.collisions;
177 static struct ip_tunnel *ipip_tunnel_lookup(struct net *net,
178 __be32 remote, __be32 local)
180 unsigned int h0 = HASH(remote);
181 unsigned int h1 = HASH(local);
183 struct ipip_net *ipn = net_generic(net, ipip_net_id);
185 for_each_ip_tunnel_rcu(t, ipn->tunnels_r_l[h0 ^ h1])
186 if (local == t->parms.iph.saddr &&
187 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
190 for_each_ip_tunnel_rcu(t, ipn->tunnels_r[h0])
191 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
194 for_each_ip_tunnel_rcu(t, ipn->tunnels_l[h1])
195 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
198 t = rcu_dereference(ipn->tunnels_wc[0]);
199 if (t && (t->dev->flags&IFF_UP))
204 static struct ip_tunnel __rcu **__ipip_bucket(struct ipip_net *ipn,
205 struct ip_tunnel_parm *parms)
207 __be32 remote = parms->iph.daddr;
208 __be32 local = parms->iph.saddr;
220 return &ipn->tunnels[prio][h];
223 static inline struct ip_tunnel __rcu **ipip_bucket(struct ipip_net *ipn,
226 return __ipip_bucket(ipn, &t->parms);
229 static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
231 struct ip_tunnel __rcu **tp;
232 struct ip_tunnel *iter;
234 for (tp = ipip_bucket(ipn, t);
235 (iter = rtnl_dereference(*tp)) != NULL;
238 rcu_assign_pointer(*tp, t->next);
244 static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
246 struct ip_tunnel __rcu **tp = ipip_bucket(ipn, t);
248 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
249 rcu_assign_pointer(*tp, t);
252 static int ipip_tunnel_create(struct net_device *dev)
254 struct ip_tunnel *t = netdev_priv(dev);
255 struct net *net = dev_net(dev);
256 struct ipip_net *ipn = net_generic(net, ipip_net_id);
259 err = ipip_tunnel_init(dev);
263 err = register_netdevice(dev);
267 strcpy(t->parms.name, dev->name);
268 dev->rtnl_link_ops = &ipip_link_ops;
271 ipip_tunnel_link(ipn, t);
278 static struct ip_tunnel *ipip_tunnel_locate(struct net *net,
279 struct ip_tunnel_parm *parms, int create)
281 __be32 remote = parms->iph.daddr;
282 __be32 local = parms->iph.saddr;
283 struct ip_tunnel *t, *nt;
284 struct ip_tunnel __rcu **tp;
285 struct net_device *dev;
287 struct ipip_net *ipn = net_generic(net, ipip_net_id);
289 for (tp = __ipip_bucket(ipn, parms);
290 (t = rtnl_dereference(*tp)) != NULL;
292 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
299 strlcpy(name, parms->name, IFNAMSIZ);
301 strcpy(name, "tunl%d");
303 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
307 dev_net_set(dev, net);
309 nt = netdev_priv(dev);
312 if (ipip_tunnel_create(dev) < 0)
322 /* called with RTNL */
323 static void ipip_tunnel_uninit(struct net_device *dev)
325 struct net *net = dev_net(dev);
326 struct ipip_net *ipn = net_generic(net, ipip_net_id);
328 if (dev == ipn->fb_tunnel_dev)
329 RCU_INIT_POINTER(ipn->tunnels_wc[0], NULL);
331 ipip_tunnel_unlink(ipn, netdev_priv(dev));
335 static int ipip_err(struct sk_buff *skb, u32 info)
338 /* All the routers (except for Linux) return only
339 8 bytes of packet payload. It means, that precise relaying of
340 ICMP in the real Internet is absolutely infeasible.
342 const struct iphdr *iph = (const struct iphdr *)skb->data;
343 const int type = icmp_hdr(skb)->type;
344 const int code = icmp_hdr(skb)->code;
350 case ICMP_PARAMETERPROB:
353 case ICMP_DEST_UNREACH:
356 case ICMP_PORT_UNREACH:
357 /* Impossible event. */
360 /* All others are translated to HOST_UNREACH.
361 rfc2003 contains "deep thoughts" about NET_UNREACH,
362 I believe they are just ether pollution. --ANK
367 case ICMP_TIME_EXCEEDED:
368 if (code != ICMP_EXC_TTL)
376 t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
380 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
381 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
382 t->dev->ifindex, 0, IPPROTO_IPIP, 0);
387 if (type == ICMP_REDIRECT) {
388 ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
394 if (t->parms.iph.daddr == 0)
398 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
401 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
405 t->err_time = jiffies;
411 static int ipip_rcv(struct sk_buff *skb)
413 struct ip_tunnel *tunnel;
414 const struct iphdr *iph = ip_hdr(skb);
417 tunnel = ipip_tunnel_lookup(dev_net(skb->dev), iph->saddr, iph->daddr);
418 if (tunnel != NULL) {
419 struct pcpu_tstats *tstats;
421 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
426 skb->mac_header = skb->network_header;
427 skb_reset_network_header(skb);
428 skb->protocol = htons(ETH_P_IP);
429 skb->pkt_type = PACKET_HOST;
431 __skb_tunnel_rx(skb, tunnel->dev);
433 err = IP_ECN_decapsulate(iph, skb);
436 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
437 &iph->saddr, iph->tos);
439 ++tunnel->dev->stats.rx_frame_errors;
440 ++tunnel->dev->stats.rx_errors;
445 tstats = this_cpu_ptr(tunnel->dev->tstats);
446 u64_stats_update_begin(&tstats->syncp);
447 tstats->rx_packets++;
448 tstats->rx_bytes += skb->len;
449 u64_stats_update_end(&tstats->syncp);
463 * This function assumes it is being called from dev_queue_xmit()
464 * and that skb is filled properly by that function.
467 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
469 struct ip_tunnel *tunnel = netdev_priv(dev);
470 const struct iphdr *tiph = &tunnel->parms.iph;
471 u8 tos = tunnel->parms.iph.tos;
472 __be16 df = tiph->frag_off;
473 struct rtable *rt; /* Route to the other host */
474 struct net_device *tdev; /* Device to other host */
475 const struct iphdr *old_iph;
476 struct iphdr *iph; /* Our new IP header */
477 unsigned int max_headroom; /* The extra header space needed */
478 __be32 dst = tiph->daddr;
484 if (skb->protocol != htons(ETH_P_IP))
486 old_iph = ip_hdr(skb);
493 if ((rt = skb_rtable(skb)) == NULL) {
494 dev->stats.tx_fifo_errors++;
497 dst = rt_nexthop(rt, old_iph->daddr);
500 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
503 IPPROTO_IPIP, RT_TOS(tos),
506 dev->stats.tx_carrier_errors++;
513 dev->stats.collisions++;
517 df |= old_iph->frag_off & htons(IP_DF);
520 mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
523 dev->stats.collisions++;
529 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
531 if ((old_iph->frag_off & htons(IP_DF)) &&
532 mtu < ntohs(old_iph->tot_len)) {
533 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
540 if (tunnel->err_count > 0) {
541 if (time_before(jiffies,
542 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
544 dst_link_failure(skb);
546 tunnel->err_count = 0;
550 * Okay, now see if we can stuff it in the buffer as-is.
552 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
554 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
555 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
556 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
559 dev->stats.tx_dropped++;
564 skb_set_owner_w(new_skb, skb->sk);
567 old_iph = ip_hdr(skb);
570 if (!skb->encapsulation) {
571 skb_reset_inner_headers(skb);
572 skb->encapsulation = 1;
574 if (skb->ip_summed != CHECKSUM_PARTIAL)
575 skb->ip_summed = CHECKSUM_NONE;
577 skb->transport_header = skb->network_header;
578 skb_push(skb, sizeof(struct iphdr));
579 skb_reset_network_header(skb);
580 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
581 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
584 skb_dst_set(skb, &rt->dst);
587 * Push down and install the IPIP header.
592 iph->ihl = sizeof(struct iphdr)>>2;
594 iph->protocol = IPPROTO_IPIP;
595 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
596 iph->daddr = fl4.daddr;
597 iph->saddr = fl4.saddr;
598 tunnel_ip_select_ident(skb, old_iph, &rt->dst);
600 if ((iph->ttl = tiph->ttl) == 0)
601 iph->ttl = old_iph->ttl;
605 pkt_len = skb->len - skb_transport_offset(skb);
606 err = ip_local_out(skb);
607 if (likely(net_xmit_eval(err) == 0)) {
608 struct pcpu_tstats *tstats = this_cpu_ptr(dev->tstats);
610 u64_stats_update_begin(&tstats->syncp);
611 tstats->tx_bytes += pkt_len;
612 tstats->tx_packets++;
613 u64_stats_update_end(&tstats->syncp);
615 dev->stats.tx_errors++;
616 dev->stats.tx_aborted_errors++;
622 dst_link_failure(skb);
624 dev->stats.tx_errors++;
629 static void ipip_tunnel_bind_dev(struct net_device *dev)
631 struct net_device *tdev = NULL;
632 struct ip_tunnel *tunnel;
633 const struct iphdr *iph;
635 tunnel = netdev_priv(dev);
636 iph = &tunnel->parms.iph;
642 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
643 iph->daddr, iph->saddr,
652 dev->flags |= IFF_POINTOPOINT;
655 if (!tdev && tunnel->parms.link)
656 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
659 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
660 dev->mtu = tdev->mtu - sizeof(struct iphdr);
662 dev->iflink = tunnel->parms.link;
665 static void ipip_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
667 struct net *net = dev_net(t->dev);
668 struct ipip_net *ipn = net_generic(net, ipip_net_id);
670 ipip_tunnel_unlink(ipn, t);
672 t->parms.iph.saddr = p->iph.saddr;
673 t->parms.iph.daddr = p->iph.daddr;
674 memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
675 memcpy(t->dev->broadcast, &p->iph.daddr, 4);
676 ipip_tunnel_link(ipn, t);
677 t->parms.iph.ttl = p->iph.ttl;
678 t->parms.iph.tos = p->iph.tos;
679 t->parms.iph.frag_off = p->iph.frag_off;
680 if (t->parms.link != p->link) {
681 t->parms.link = p->link;
682 ipip_tunnel_bind_dev(t->dev);
684 netdev_state_change(t->dev);
688 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
691 struct ip_tunnel_parm p;
693 struct net *net = dev_net(dev);
694 struct ipip_net *ipn = net_generic(net, ipip_net_id);
699 if (dev == ipn->fb_tunnel_dev) {
700 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
704 t = ipip_tunnel_locate(net, &p, 0);
707 t = netdev_priv(dev);
708 memcpy(&p, &t->parms, sizeof(p));
709 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
716 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
720 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
724 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
725 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
728 p.iph.frag_off |= htons(IP_DF);
730 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
732 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
739 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
740 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
744 t = netdev_priv(dev);
747 ipip_tunnel_update(t, &p);
752 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
755 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
760 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
763 if (dev == ipn->fb_tunnel_dev) {
765 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
768 if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
771 if (t->dev == ipn->fb_tunnel_dev)
775 unregister_netdevice(dev);
787 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
789 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
795 static const struct net_device_ops ipip_netdev_ops = {
796 .ndo_uninit = ipip_tunnel_uninit,
797 .ndo_start_xmit = ipip_tunnel_xmit,
798 .ndo_do_ioctl = ipip_tunnel_ioctl,
799 .ndo_change_mtu = ipip_tunnel_change_mtu,
800 .ndo_get_stats64 = ipip_get_stats64,
803 static void ipip_dev_free(struct net_device *dev)
805 free_percpu(dev->tstats);
809 #define IPIP_FEATURES (NETIF_F_SG | \
814 static void ipip_tunnel_setup(struct net_device *dev)
816 dev->netdev_ops = &ipip_netdev_ops;
817 dev->destructor = ipip_dev_free;
819 dev->type = ARPHRD_TUNNEL;
820 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
821 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
822 dev->flags = IFF_NOARP;
825 dev->features |= NETIF_F_NETNS_LOCAL;
826 dev->features |= NETIF_F_LLTX;
827 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
829 dev->features |= IPIP_FEATURES;
830 dev->hw_features |= IPIP_FEATURES;
833 static int ipip_tunnel_init(struct net_device *dev)
835 struct ip_tunnel *tunnel = netdev_priv(dev);
839 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
840 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
842 ipip_tunnel_bind_dev(dev);
844 dev->tstats = alloc_percpu(struct pcpu_tstats);
851 static int __net_init ipip_fb_tunnel_init(struct net_device *dev)
853 struct ip_tunnel *tunnel = netdev_priv(dev);
854 struct iphdr *iph = &tunnel->parms.iph;
855 struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
858 strcpy(tunnel->parms.name, dev->name);
861 iph->protocol = IPPROTO_IPIP;
864 dev->tstats = alloc_percpu(struct pcpu_tstats);
869 rcu_assign_pointer(ipn->tunnels_wc[0], tunnel);
873 static void ipip_netlink_parms(struct nlattr *data[],
874 struct ip_tunnel_parm *parms)
876 memset(parms, 0, sizeof(*parms));
878 parms->iph.version = 4;
879 parms->iph.protocol = IPPROTO_IPIP;
885 if (data[IFLA_IPTUN_LINK])
886 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
888 if (data[IFLA_IPTUN_LOCAL])
889 parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
891 if (data[IFLA_IPTUN_REMOTE])
892 parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
894 if (data[IFLA_IPTUN_TTL]) {
895 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
897 parms->iph.frag_off = htons(IP_DF);
900 if (data[IFLA_IPTUN_TOS])
901 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
903 if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
904 parms->iph.frag_off = htons(IP_DF);
907 static int ipip_newlink(struct net *src_net, struct net_device *dev,
908 struct nlattr *tb[], struct nlattr *data[])
910 struct net *net = dev_net(dev);
911 struct ip_tunnel *nt;
913 nt = netdev_priv(dev);
914 ipip_netlink_parms(data, &nt->parms);
916 if (ipip_tunnel_locate(net, &nt->parms, 0))
919 return ipip_tunnel_create(dev);
922 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
923 struct nlattr *data[])
926 struct ip_tunnel_parm p;
927 struct net *net = dev_net(dev);
928 struct ipip_net *ipn = net_generic(net, ipip_net_id);
930 if (dev == ipn->fb_tunnel_dev)
933 ipip_netlink_parms(data, &p);
935 if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
936 (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
939 t = ipip_tunnel_locate(net, &p, 0);
945 t = netdev_priv(dev);
947 ipip_tunnel_update(t, &p);
951 static size_t ipip_get_size(const struct net_device *dev)
954 /* IFLA_IPTUN_LINK */
956 /* IFLA_IPTUN_LOCAL */
958 /* IFLA_IPTUN_REMOTE */
964 /* IFLA_IPTUN_PMTUDISC */
969 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
971 struct ip_tunnel *tunnel = netdev_priv(dev);
972 struct ip_tunnel_parm *parm = &tunnel->parms;
974 if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
975 nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
976 nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
977 nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
978 nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
979 nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
980 !!(parm->iph.frag_off & htons(IP_DF))))
981 goto nla_put_failure;
988 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
989 [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
990 [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
991 [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
992 [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
993 [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
994 [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
997 static struct rtnl_link_ops ipip_link_ops __read_mostly = {
999 .maxtype = IFLA_IPTUN_MAX,
1000 .policy = ipip_policy,
1001 .priv_size = sizeof(struct ip_tunnel),
1002 .setup = ipip_tunnel_setup,
1003 .newlink = ipip_newlink,
1004 .changelink = ipip_changelink,
1005 .get_size = ipip_get_size,
1006 .fill_info = ipip_fill_info,
1009 static struct xfrm_tunnel ipip_handler __read_mostly = {
1010 .handler = ipip_rcv,
1011 .err_handler = ipip_err,
1015 static const char banner[] __initconst =
1016 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
1018 static void ipip_destroy_tunnels(struct ipip_net *ipn, struct list_head *head)
1022 for (prio = 1; prio < 4; prio++) {
1024 for (h = 0; h < HASH_SIZE; h++) {
1025 struct ip_tunnel *t;
1027 t = rtnl_dereference(ipn->tunnels[prio][h]);
1029 unregister_netdevice_queue(t->dev, head);
1030 t = rtnl_dereference(t->next);
1036 static int __net_init ipip_init_net(struct net *net)
1038 struct ipip_net *ipn = net_generic(net, ipip_net_id);
1039 struct ip_tunnel *t;
1042 ipn->tunnels[0] = ipn->tunnels_wc;
1043 ipn->tunnels[1] = ipn->tunnels_l;
1044 ipn->tunnels[2] = ipn->tunnels_r;
1045 ipn->tunnels[3] = ipn->tunnels_r_l;
1047 ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
1050 if (!ipn->fb_tunnel_dev) {
1054 dev_net_set(ipn->fb_tunnel_dev, net);
1056 err = ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
1060 if ((err = register_netdev(ipn->fb_tunnel_dev)))
1063 t = netdev_priv(ipn->fb_tunnel_dev);
1065 strcpy(t->parms.name, ipn->fb_tunnel_dev->name);
1069 ipip_dev_free(ipn->fb_tunnel_dev);
1075 static void __net_exit ipip_exit_net(struct net *net)
1077 struct ipip_net *ipn = net_generic(net, ipip_net_id);
1081 ipip_destroy_tunnels(ipn, &list);
1082 unregister_netdevice_queue(ipn->fb_tunnel_dev, &list);
1083 unregister_netdevice_many(&list);
1087 static struct pernet_operations ipip_net_ops = {
1088 .init = ipip_init_net,
1089 .exit = ipip_exit_net,
1091 .size = sizeof(struct ipip_net),
1094 static int __init ipip_init(void)
1100 err = register_pernet_device(&ipip_net_ops);
1103 err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1105 pr_info("%s: can't register tunnel\n", __func__);
1106 goto xfrm_tunnel_failed;
1108 err = rtnl_link_register(&ipip_link_ops);
1110 goto rtnl_link_failed;
1116 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1118 unregister_pernet_device(&ipip_net_ops);
1122 static void __exit ipip_fini(void)
1124 rtnl_link_unregister(&ipip_link_ops);
1125 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
1126 pr_info("%s: can't deregister tunnel\n", __func__);
1128 unregister_pernet_device(&ipip_net_ops);
1131 module_init(ipip_init);
1132 module_exit(ipip_fini);
1133 MODULE_LICENSE("GPL");
1134 MODULE_ALIAS_NETDEV("tunl0");