Linux Audio

Check our new training course

Loading...
v3.15
   1/*
   2 *	IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
   3 *	Linux INET6 implementation
   4 *
   5 *	Authors:
   6 *	Pedro Roque		<roque@di.fc.ul.pt>
   7 *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
   8 *
   9 *	This program is free software; you can redistribute it and/or
  10 *      modify it under the terms of the GNU General Public License
  11 *      as published by the Free Software Foundation; either version
  12 *      2 of the License, or (at your option) any later version.
  13 *
  14 *	Changes:
  15 * Roger Venning <r.venning@telstra.com>:	6to4 support
  16 * Nate Thompson <nate@thebog.net>:		6to4 support
  17 * Fred Templin <fred.l.templin@boeing.com>:	isatap support
  18 */
  19
  20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22#include <linux/module.h>
  23#include <linux/capability.h>
  24#include <linux/errno.h>
  25#include <linux/types.h>
  26#include <linux/socket.h>
  27#include <linux/sockios.h>
  28#include <linux/net.h>
  29#include <linux/in6.h>
  30#include <linux/netdevice.h>
  31#include <linux/if_arp.h>
  32#include <linux/icmp.h>
  33#include <linux/slab.h>
  34#include <asm/uaccess.h>
  35#include <linux/init.h>
  36#include <linux/netfilter_ipv4.h>
  37#include <linux/if_ether.h>
  38
  39#include <net/sock.h>
  40#include <net/snmp.h>
  41
  42#include <net/ipv6.h>
  43#include <net/protocol.h>
  44#include <net/transp_v6.h>
  45#include <net/ip6_fib.h>
  46#include <net/ip6_route.h>
  47#include <net/ndisc.h>
  48#include <net/addrconf.h>
  49#include <net/ip.h>
  50#include <net/udp.h>
  51#include <net/icmp.h>
  52#include <net/ip_tunnels.h>
  53#include <net/inet_ecn.h>
  54#include <net/xfrm.h>
  55#include <net/dsfield.h>
  56#include <net/net_namespace.h>
  57#include <net/netns/generic.h>
  58
  59/*
  60   This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c
  61
  62   For comments look at net/ipv4/ip_gre.c --ANK
  63 */
  64
  65#define HASH_SIZE  16
  66#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
  67
  68static bool log_ecn_error = true;
  69module_param(log_ecn_error, bool, 0644);
  70MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  71
  72static int ipip6_tunnel_init(struct net_device *dev);
  73static void ipip6_tunnel_setup(struct net_device *dev);
  74static void ipip6_dev_free(struct net_device *dev);
  75static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
  76		      __be32 *v4dst);
  77static struct rtnl_link_ops sit_link_ops __read_mostly;
  78
  79static int sit_net_id __read_mostly;
  80struct sit_net {
  81	struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
  82	struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
  83	struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
  84	struct ip_tunnel __rcu *tunnels_wc[1];
  85	struct ip_tunnel __rcu **tunnels[4];
  86
  87	struct net_device *fb_tunnel_dev;
  88};
  89
  90/*
  91 * Must be invoked with rcu_read_lock
  92 */
  93static struct ip_tunnel *ipip6_tunnel_lookup(struct net *net,
  94		struct net_device *dev, __be32 remote, __be32 local)
 
 
  95{
  96	unsigned int h0 = HASH(remote);
  97	unsigned int h1 = HASH(local);
  98	struct ip_tunnel *t;
  99	struct sit_net *sitn = net_generic(net, sit_net_id);
 
 100
 101	for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) {
 102		if (local == t->parms.iph.saddr &&
 103		    remote == t->parms.iph.daddr &&
 104		    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
 
 105		    (t->dev->flags & IFF_UP))
 106			return t;
 107	}
 108	for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) {
 109		if (remote == t->parms.iph.daddr &&
 110		    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
 
 111		    (t->dev->flags & IFF_UP))
 112			return t;
 113	}
 114	for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) {
 115		if (local == t->parms.iph.saddr &&
 116		    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
 
 117		    (t->dev->flags & IFF_UP))
 118			return t;
 119	}
 120	t = rcu_dereference(sitn->tunnels_wc[0]);
 121	if ((t != NULL) && (t->dev->flags & IFF_UP))
 122		return t;
 123	return NULL;
 124}
 125
 126static struct ip_tunnel __rcu **__ipip6_bucket(struct sit_net *sitn,
 127		struct ip_tunnel_parm *parms)
 128{
 129	__be32 remote = parms->iph.daddr;
 130	__be32 local = parms->iph.saddr;
 131	unsigned int h = 0;
 132	int prio = 0;
 133
 134	if (remote) {
 135		prio |= 2;
 136		h ^= HASH(remote);
 137	}
 138	if (local) {
 139		prio |= 1;
 140		h ^= HASH(local);
 141	}
 142	return &sitn->tunnels[prio][h];
 143}
 144
 145static inline struct ip_tunnel __rcu **ipip6_bucket(struct sit_net *sitn,
 146		struct ip_tunnel *t)
 147{
 148	return __ipip6_bucket(sitn, &t->parms);
 149}
 150
 151static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t)
 152{
 153	struct ip_tunnel __rcu **tp;
 154	struct ip_tunnel *iter;
 155
 156	for (tp = ipip6_bucket(sitn, t);
 157	     (iter = rtnl_dereference(*tp)) != NULL;
 158	     tp = &iter->next) {
 159		if (t == iter) {
 160			rcu_assign_pointer(*tp, t->next);
 161			break;
 162		}
 163	}
 164}
 165
 166static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t)
 167{
 168	struct ip_tunnel __rcu **tp = ipip6_bucket(sitn, t);
 169
 170	rcu_assign_pointer(t->next, rtnl_dereference(*tp));
 171	rcu_assign_pointer(*tp, t);
 172}
 173
 174static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn)
 175{
 176#ifdef CONFIG_IPV6_SIT_6RD
 177	struct ip_tunnel *t = netdev_priv(dev);
 178
 179	if (t->dev == sitn->fb_tunnel_dev) {
 180		ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0);
 181		t->ip6rd.relay_prefix = 0;
 182		t->ip6rd.prefixlen = 16;
 183		t->ip6rd.relay_prefixlen = 0;
 184	} else {
 185		struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev);
 186		memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd));
 187	}
 188#endif
 189}
 190
 191static int ipip6_tunnel_create(struct net_device *dev)
 192{
 193	struct ip_tunnel *t = netdev_priv(dev);
 194	struct net *net = dev_net(dev);
 195	struct sit_net *sitn = net_generic(net, sit_net_id);
 196	int err;
 197
 198	err = ipip6_tunnel_init(dev);
 199	if (err < 0)
 200		goto out;
 201	ipip6_tunnel_clone_6rd(dev, sitn);
 202
 203	if ((__force u16)t->parms.i_flags & SIT_ISATAP)
 204		dev->priv_flags |= IFF_ISATAP;
 205
 
 
 206	err = register_netdevice(dev);
 207	if (err < 0)
 208		goto out;
 209
 210	strcpy(t->parms.name, dev->name);
 211	dev->rtnl_link_ops = &sit_link_ops;
 212
 213	dev_hold(dev);
 214
 215	ipip6_tunnel_link(sitn, t);
 216	return 0;
 217
 218out:
 219	return err;
 220}
 221
 222static struct ip_tunnel *ipip6_tunnel_locate(struct net *net,
 223		struct ip_tunnel_parm *parms, int create)
 224{
 225	__be32 remote = parms->iph.daddr;
 226	__be32 local = parms->iph.saddr;
 227	struct ip_tunnel *t, *nt;
 228	struct ip_tunnel __rcu **tp;
 229	struct net_device *dev;
 230	char name[IFNAMSIZ];
 231	struct sit_net *sitn = net_generic(net, sit_net_id);
 232
 233	for (tp = __ipip6_bucket(sitn, parms);
 234	    (t = rtnl_dereference(*tp)) != NULL;
 235	     tp = &t->next) {
 236		if (local == t->parms.iph.saddr &&
 237		    remote == t->parms.iph.daddr &&
 238		    parms->link == t->parms.link) {
 239			if (create)
 240				return NULL;
 241			else
 242				return t;
 243		}
 244	}
 245	if (!create)
 246		goto failed;
 247
 248	if (parms->name[0])
 
 
 249		strlcpy(name, parms->name, IFNAMSIZ);
 250	else
 251		strcpy(name, "sit%d");
 252
 253	dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
 254	if (dev == NULL)
 
 255		return NULL;
 256
 257	dev_net_set(dev, net);
 258
 259	nt = netdev_priv(dev);
 260
 261	nt->parms = *parms;
 262	if (ipip6_tunnel_create(dev) < 0)
 263		goto failed_free;
 264
 265	return nt;
 266
 267failed_free:
 268	ipip6_dev_free(dev);
 269failed:
 270	return NULL;
 271}
 272
 273#define for_each_prl_rcu(start)			\
 274	for (prl = rcu_dereference(start);	\
 275	     prl;				\
 276	     prl = rcu_dereference(prl->next))
 277
 278static struct ip_tunnel_prl_entry *
 279__ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
 280{
 281	struct ip_tunnel_prl_entry *prl;
 282
 283	for_each_prl_rcu(t->prl)
 284		if (prl->addr == addr)
 285			break;
 286	return prl;
 287
 288}
 289
 290static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
 291				struct ip_tunnel_prl __user *a)
 292{
 293	struct ip_tunnel_prl kprl, *kp;
 294	struct ip_tunnel_prl_entry *prl;
 295	unsigned int cmax, c = 0, ca, len;
 296	int ret = 0;
 297
 298	if (copy_from_user(&kprl, a, sizeof(kprl)))
 299		return -EFAULT;
 300	cmax = kprl.datalen / sizeof(kprl);
 301	if (cmax > 1 && kprl.addr != htonl(INADDR_ANY))
 302		cmax = 1;
 303
 304	/* For simple GET or for root users,
 305	 * we try harder to allocate.
 306	 */
 307	kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
 308		kcalloc(cmax, sizeof(*kp), GFP_KERNEL) :
 309		NULL;
 310
 311	rcu_read_lock();
 312
 313	ca = t->prl_count < cmax ? t->prl_count : cmax;
 314
 315	if (!kp) {
 316		/* We don't try hard to allocate much memory for
 317		 * non-root users.
 318		 * For root users, retry allocating enough memory for
 319		 * the answer.
 320		 */
 321		kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC);
 322		if (!kp) {
 323			ret = -ENOMEM;
 324			goto out;
 325		}
 326	}
 327
 328	c = 0;
 329	for_each_prl_rcu(t->prl) {
 330		if (c >= cmax)
 331			break;
 332		if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
 333			continue;
 334		kp[c].addr = prl->addr;
 335		kp[c].flags = prl->flags;
 336		c++;
 337		if (kprl.addr != htonl(INADDR_ANY))
 338			break;
 339	}
 340out:
 341	rcu_read_unlock();
 342
 343	len = sizeof(*kp) * c;
 344	ret = 0;
 345	if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
 346		ret = -EFAULT;
 347
 348	kfree(kp);
 349
 350	return ret;
 351}
 352
 353static int
 354ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
 355{
 356	struct ip_tunnel_prl_entry *p;
 357	int err = 0;
 358
 359	if (a->addr == htonl(INADDR_ANY))
 360		return -EINVAL;
 361
 362	ASSERT_RTNL();
 363
 364	for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) {
 365		if (p->addr == a->addr) {
 366			if (chg) {
 367				p->flags = a->flags;
 368				goto out;
 369			}
 370			err = -EEXIST;
 371			goto out;
 372		}
 373	}
 374
 375	if (chg) {
 376		err = -ENXIO;
 377		goto out;
 378	}
 379
 380	p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
 381	if (!p) {
 382		err = -ENOBUFS;
 383		goto out;
 384	}
 385
 386	p->next = t->prl;
 387	p->addr = a->addr;
 388	p->flags = a->flags;
 389	t->prl_count++;
 390	rcu_assign_pointer(t->prl, p);
 391out:
 392	return err;
 393}
 394
 395static void prl_list_destroy_rcu(struct rcu_head *head)
 396{
 397	struct ip_tunnel_prl_entry *p, *n;
 398
 399	p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
 400	do {
 401		n = rcu_dereference_protected(p->next, 1);
 402		kfree(p);
 403		p = n;
 404	} while (p);
 405}
 406
 407static int
 408ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
 409{
 410	struct ip_tunnel_prl_entry *x;
 411	struct ip_tunnel_prl_entry __rcu **p;
 412	int err = 0;
 413
 414	ASSERT_RTNL();
 415
 416	if (a && a->addr != htonl(INADDR_ANY)) {
 417		for (p = &t->prl;
 418		     (x = rtnl_dereference(*p)) != NULL;
 419		     p = &x->next) {
 420			if (x->addr == a->addr) {
 421				*p = x->next;
 422				kfree_rcu(x, rcu_head);
 423				t->prl_count--;
 424				goto out;
 425			}
 426		}
 427		err = -ENXIO;
 428	} else {
 429		x = rtnl_dereference(t->prl);
 430		if (x) {
 431			t->prl_count = 0;
 432			call_rcu(&x->rcu_head, prl_list_destroy_rcu);
 433			t->prl = NULL;
 434		}
 435	}
 436out:
 437	return err;
 438}
 439
 440static int
 441isatap_chksrc(struct sk_buff *skb, const struct iphdr *iph, struct ip_tunnel *t)
 442{
 443	struct ip_tunnel_prl_entry *p;
 444	int ok = 1;
 445
 446	rcu_read_lock();
 447	p = __ipip6_tunnel_locate_prl(t, iph->saddr);
 448	if (p) {
 449		if (p->flags & PRL_DEFAULT)
 450			skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
 451		else
 452			skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
 453	} else {
 454		const struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;
 455
 456		if (ipv6_addr_is_isatap(addr6) &&
 457		    (addr6->s6_addr32[3] == iph->saddr) &&
 458		    ipv6_chk_prefix(addr6, t->dev))
 459			skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
 460		else
 461			ok = 0;
 462	}
 463	rcu_read_unlock();
 464	return ok;
 465}
 466
 467static void ipip6_tunnel_uninit(struct net_device *dev)
 468{
 469	struct ip_tunnel *tunnel = netdev_priv(dev);
 470	struct sit_net *sitn = net_generic(tunnel->net, sit_net_id);
 471
 472	if (dev == sitn->fb_tunnel_dev) {
 473		RCU_INIT_POINTER(sitn->tunnels_wc[0], NULL);
 474	} else {
 475		ipip6_tunnel_unlink(sitn, tunnel);
 476		ipip6_tunnel_del_prl(tunnel, NULL);
 477	}
 478	ip_tunnel_dst_reset_all(tunnel);
 479	dev_put(dev);
 480}
 481
 482/* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
 483 * if sufficient data bytes are available
 484 */
 485static int ipip6_err_gen_icmpv6_unreach(struct sk_buff *skb)
 486{
 487	const struct iphdr *iph = (const struct iphdr *) skb->data;
 488	struct rt6_info *rt;
 489	struct sk_buff *skb2;
 490
 491	if (!pskb_may_pull(skb, iph->ihl * 4 + sizeof(struct ipv6hdr) + 8))
 492		return 1;
 493
 494	skb2 = skb_clone(skb, GFP_ATOMIC);
 495
 496	if (!skb2)
 497		return 1;
 498
 499	skb_dst_drop(skb2);
 500	skb_pull(skb2, iph->ihl * 4);
 501	skb_reset_network_header(skb2);
 502
 503	rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0, 0);
 504
 505	if (rt && rt->dst.dev)
 506		skb2->dev = rt->dst.dev;
 507
 508	icmpv6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
 509
 510	if (rt)
 511		ip6_rt_put(rt);
 512
 513	kfree_skb(skb2);
 514
 515	return 0;
 516}
 517
 518static int ipip6_err(struct sk_buff *skb, u32 info)
 519{
 520	const struct iphdr *iph = (const struct iphdr *)skb->data;
 521	const int type = icmp_hdr(skb)->type;
 522	const int code = icmp_hdr(skb)->code;
 
 523	struct ip_tunnel *t;
 
 524	int err;
 525
 526	switch (type) {
 527	default:
 528	case ICMP_PARAMETERPROB:
 529		return 0;
 530
 531	case ICMP_DEST_UNREACH:
 532		switch (code) {
 533		case ICMP_SR_FAILED:
 534			/* Impossible event. */
 535			return 0;
 536		default:
 537			/* All others are translated to HOST_UNREACH.
 538			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 539			   I believe they are just ether pollution. --ANK
 540			 */
 541			break;
 542		}
 543		break;
 544	case ICMP_TIME_EXCEEDED:
 545		if (code != ICMP_EXC_TTL)
 546			return 0;
 
 547		break;
 548	case ICMP_REDIRECT:
 549		break;
 550	}
 551
 552	err = -ENOENT;
 553
 554	t = ipip6_tunnel_lookup(dev_net(skb->dev),
 555				skb->dev,
 556				iph->daddr,
 557				iph->saddr);
 558	if (t == NULL)
 559		goto out;
 560
 561	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 562		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 563				 t->dev->ifindex, 0, IPPROTO_IPV6, 0);
 564		err = 0;
 565		goto out;
 566	}
 567	if (type == ICMP_REDIRECT) {
 568		ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
 569			      IPPROTO_IPV6, 0);
 570		err = 0;
 571		goto out;
 572	}
 573
 574	if (t->parms.iph.daddr == 0)
 
 575		goto out;
 576
 577	err = 0;
 578	if (!ipip6_err_gen_icmpv6_unreach(skb))
 579		goto out;
 580
 581	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 582		goto out;
 583
 584	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 585		t->err_count++;
 586	else
 587		t->err_count = 1;
 588	t->err_time = jiffies;
 589out:
 590	return err;
 591}
 592
 593static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
 594				  const struct in6_addr *v6addr)
 595{
 596	__be32 v4embed = 0;
 597	if (check_6rd(tunnel, v6addr, &v4embed) && v4addr != v4embed)
 598		return true;
 599	return false;
 600}
 601
 602/* Checks if an address matches an address on the tunnel interface.
 603 * Used to detect the NAT of proto 41 packets and let them pass spoofing test.
 604 * Long story:
 605 * This function is called after we considered the packet as spoofed
 606 * in is_spoofed_6rd.
 607 * We may have a router that is doing NAT for proto 41 packets
 608 * for an internal station. Destination a.a.a.a/PREFIX:bbbb:bbbb
 609 * will be translated to n.n.n.n/PREFIX:bbbb:bbbb. And is_spoofed_6rd
 610 * function will return true, dropping the packet.
 611 * But, we can still check if is spoofed against the IP
 612 * addresses associated with the interface.
 613 */
 614static bool only_dnatted(const struct ip_tunnel *tunnel,
 615	const struct in6_addr *v6dst)
 616{
 617	int prefix_len;
 618
 619#ifdef CONFIG_IPV6_SIT_6RD
 620	prefix_len = tunnel->ip6rd.prefixlen + 32
 621		- tunnel->ip6rd.relay_prefixlen;
 622#else
 623	prefix_len = 48;
 624#endif
 625	return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
 626}
 627
 628/* Returns true if a packet is spoofed */
 629static bool packet_is_spoofed(struct sk_buff *skb,
 630			      const struct iphdr *iph,
 631			      struct ip_tunnel *tunnel)
 632{
 633	const struct ipv6hdr *ipv6h;
 634
 635	if (tunnel->dev->priv_flags & IFF_ISATAP) {
 636		if (!isatap_chksrc(skb, iph, tunnel))
 637			return true;
 638
 639		return false;
 640	}
 641
 642	if (tunnel->dev->flags & IFF_POINTOPOINT)
 643		return false;
 644
 645	ipv6h = ipv6_hdr(skb);
 646
 647	if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
 648		net_warn_ratelimited("Src spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
 649				     &iph->saddr, &ipv6h->saddr,
 650				     &iph->daddr, &ipv6h->daddr);
 651		return true;
 652	}
 653
 654	if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
 655		return false;
 656
 657	if (only_dnatted(tunnel, &ipv6h->daddr))
 658		return false;
 659
 660	net_warn_ratelimited("Dst spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
 661			     &iph->saddr, &ipv6h->saddr,
 662			     &iph->daddr, &ipv6h->daddr);
 663	return true;
 664}
 665
 666static int ipip6_rcv(struct sk_buff *skb)
 667{
 668	const struct iphdr *iph = ip_hdr(skb);
 669	struct ip_tunnel *tunnel;
 
 670	int err;
 671
 
 672	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
 673				     iph->saddr, iph->daddr);
 674	if (tunnel != NULL) {
 675		struct pcpu_sw_netstats *tstats;
 676
 677		if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
 678		    tunnel->parms.iph.protocol != 0)
 679			goto out;
 680
 681		skb->mac_header = skb->network_header;
 682		skb_reset_network_header(skb);
 683		IPCB(skb)->flags = 0;
 684		skb->protocol = htons(ETH_P_IPV6);
 685
 686		if (packet_is_spoofed(skb, iph, tunnel)) {
 687			tunnel->dev->stats.rx_errors++;
 688			goto out;
 689		}
 690
 691		__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);
 
 
 692
 693		err = IP_ECN_decapsulate(iph, skb);
 694		if (unlikely(err)) {
 695			if (log_ecn_error)
 696				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
 697						     &iph->saddr, iph->tos);
 698			if (err > 1) {
 699				++tunnel->dev->stats.rx_frame_errors;
 700				++tunnel->dev->stats.rx_errors;
 701				goto out;
 702			}
 703		}
 704
 705		tstats = this_cpu_ptr(tunnel->dev->tstats);
 706		u64_stats_update_begin(&tstats->syncp);
 707		tstats->rx_packets++;
 708		tstats->rx_bytes += skb->len;
 709		u64_stats_update_end(&tstats->syncp);
 710
 711		netif_rx(skb);
 712
 713		return 0;
 714	}
 715
 716	/* no tunnel matched,  let upstream know, ipsec may handle it */
 717	return 1;
 718out:
 719	kfree_skb(skb);
 720	return 0;
 721}
 722
 723static const struct tnl_ptk_info tpi = {
 724	/* no tunnel info required for ipip. */
 725	.proto = htons(ETH_P_IP),
 726};
 727
 728static int ipip_rcv(struct sk_buff *skb)
 
 
 
 
 
 
 
 729{
 730	const struct iphdr *iph;
 731	struct ip_tunnel *tunnel;
 
 
 
 732
 733	iph = ip_hdr(skb);
 734	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
 735				     iph->saddr, iph->daddr);
 736	if (tunnel != NULL) {
 737		if (tunnel->parms.iph.protocol != IPPROTO_IPIP &&
 
 
 738		    tunnel->parms.iph.protocol != 0)
 739			goto drop;
 740
 741		if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 742			goto drop;
 743		if (iptunnel_pull_header(skb, 0, tpi.proto))
 
 
 
 
 
 
 744			goto drop;
 745		return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
 746	}
 747
 748	return 1;
 749
 750drop:
 751	kfree_skb(skb);
 752	return 0;
 753}
 754
 
 
 
 
 
 
 
 
 
 
 
 
 755/*
 756 * If the IPv6 address comes from 6rd / 6to4 (RFC 3056) addr space this function
 757 * stores the embedded IPv4 address in v4dst and returns true.
 758 */
 759static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
 760		      __be32 *v4dst)
 761{
 762#ifdef CONFIG_IPV6_SIT_6RD
 763	if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
 764			      tunnel->ip6rd.prefixlen)) {
 765		unsigned int pbw0, pbi0;
 766		int pbi1;
 767		u32 d;
 768
 769		pbw0 = tunnel->ip6rd.prefixlen >> 5;
 770		pbi0 = tunnel->ip6rd.prefixlen & 0x1f;
 771
 772		d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
 773		    tunnel->ip6rd.relay_prefixlen;
 774
 775		pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
 776		if (pbi1 > 0)
 777			d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
 778			     (32 - pbi1);
 779
 780		*v4dst = tunnel->ip6rd.relay_prefix | htonl(d);
 781		return true;
 782	}
 783#else
 784	if (v6dst->s6_addr16[0] == htons(0x2002)) {
 785		/* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
 786		memcpy(v4dst, &v6dst->s6_addr16[1], 4);
 787		return true;
 788	}
 789#endif
 790	return false;
 791}
 792
 793static inline __be32 try_6rd(struct ip_tunnel *tunnel,
 794			     const struct in6_addr *v6dst)
 795{
 796	__be32 dst = 0;
 797	check_6rd(tunnel, v6dst, &dst);
 798	return dst;
 799}
 800
 801/*
 802 *	This function assumes it is being called from dev_queue_xmit()
 803 *	and that skb is filled properly by that function.
 804 */
 805
 806static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
 807				     struct net_device *dev)
 808{
 809	struct ip_tunnel *tunnel = netdev_priv(dev);
 810	const struct iphdr  *tiph = &tunnel->parms.iph;
 811	const struct ipv6hdr *iph6 = ipv6_hdr(skb);
 812	u8     tos = tunnel->parms.iph.tos;
 813	__be16 df = tiph->frag_off;
 814	struct rtable *rt;     			/* Route to the other host */
 815	struct net_device *tdev;		/* Device to other host */
 816	unsigned int max_headroom;		/* The extra header space needed */
 817	__be32 dst = tiph->daddr;
 818	struct flowi4 fl4;
 819	int    mtu;
 820	const struct in6_addr *addr6;
 821	int addr_type;
 822	u8 ttl;
 823	int err;
 824
 825	if (skb->protocol != htons(ETH_P_IPV6))
 826		goto tx_error;
 827
 828	if (tos == 1)
 829		tos = ipv6_get_dsfield(iph6);
 830
 831	/* ISATAP (RFC4214) - must come before 6to4 */
 832	if (dev->priv_flags & IFF_ISATAP) {
 833		struct neighbour *neigh = NULL;
 834		bool do_tx_error = false;
 835
 836		if (skb_dst(skb))
 837			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
 838
 839		if (neigh == NULL) {
 840			net_dbg_ratelimited("nexthop == NULL\n");
 841			goto tx_error;
 842		}
 843
 844		addr6 = (const struct in6_addr *)&neigh->primary_key;
 845		addr_type = ipv6_addr_type(addr6);
 846
 847		if ((addr_type & IPV6_ADDR_UNICAST) &&
 848		     ipv6_addr_is_isatap(addr6))
 849			dst = addr6->s6_addr32[3];
 850		else
 851			do_tx_error = true;
 852
 853		neigh_release(neigh);
 854		if (do_tx_error)
 855			goto tx_error;
 856	}
 857
 858	if (!dst)
 859		dst = try_6rd(tunnel, &iph6->daddr);
 860
 861	if (!dst) {
 862		struct neighbour *neigh = NULL;
 863		bool do_tx_error = false;
 864
 865		if (skb_dst(skb))
 866			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
 867
 868		if (neigh == NULL) {
 869			net_dbg_ratelimited("nexthop == NULL\n");
 870			goto tx_error;
 871		}
 872
 873		addr6 = (const struct in6_addr *)&neigh->primary_key;
 874		addr_type = ipv6_addr_type(addr6);
 875
 876		if (addr_type == IPV6_ADDR_ANY) {
 877			addr6 = &ipv6_hdr(skb)->daddr;
 878			addr_type = ipv6_addr_type(addr6);
 879		}
 880
 881		if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
 882			dst = addr6->s6_addr32[3];
 883		else
 884			do_tx_error = true;
 885
 886		neigh_release(neigh);
 887		if (do_tx_error)
 888			goto tx_error;
 889	}
 890
 891	rt = ip_route_output_ports(tunnel->net, &fl4, NULL,
 892				   dst, tiph->saddr,
 893				   0, 0,
 894				   IPPROTO_IPV6, RT_TOS(tos),
 895				   tunnel->parms.link);
 
 896	if (IS_ERR(rt)) {
 897		dev->stats.tx_carrier_errors++;
 898		goto tx_error_icmp;
 899	}
 900	if (rt->rt_type != RTN_UNICAST) {
 901		ip_rt_put(rt);
 902		dev->stats.tx_carrier_errors++;
 903		goto tx_error_icmp;
 904	}
 905	tdev = rt->dst.dev;
 906
 907	if (tdev == dev) {
 908		ip_rt_put(rt);
 909		dev->stats.collisions++;
 910		goto tx_error;
 911	}
 912
 
 
 
 
 
 913	if (df) {
 914		mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
 915
 916		if (mtu < 68) {
 917			dev->stats.collisions++;
 918			ip_rt_put(rt);
 919			goto tx_error;
 920		}
 921
 922		if (mtu < IPV6_MIN_MTU) {
 923			mtu = IPV6_MIN_MTU;
 924			df = 0;
 925		}
 926
 927		if (tunnel->parms.iph.daddr && skb_dst(skb))
 928			skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
 929
 930		if (skb->len > mtu && !skb_is_gso(skb)) {
 931			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
 932			ip_rt_put(rt);
 933			goto tx_error;
 934		}
 935	}
 936
 937	if (tunnel->err_count > 0) {
 938		if (time_before(jiffies,
 939				tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
 940			tunnel->err_count--;
 941			dst_link_failure(skb);
 942		} else
 943			tunnel->err_count = 0;
 944	}
 945
 946	/*
 947	 * Okay, now see if we can stuff it in the buffer as-is.
 948	 */
 949	max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);
 950
 951	if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
 952	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
 953		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 954		if (!new_skb) {
 955			ip_rt_put(rt);
 956			dev->stats.tx_dropped++;
 957			kfree_skb(skb);
 958			return NETDEV_TX_OK;
 959		}
 960		if (skb->sk)
 961			skb_set_owner_w(new_skb, skb->sk);
 962		dev_kfree_skb(skb);
 963		skb = new_skb;
 964		iph6 = ipv6_hdr(skb);
 965	}
 966	ttl = tiph->ttl;
 967	if (ttl == 0)
 968		ttl = iph6->hop_limit;
 969	tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
 970
 971	skb = iptunnel_handle_offloads(skb, false, SKB_GSO_SIT);
 972	if (IS_ERR(skb)) {
 973		ip_rt_put(rt);
 974		goto out;
 975	}
 976
 977	err = iptunnel_xmit(skb->sk, rt, skb, fl4.saddr, fl4.daddr,
 978			    IPPROTO_IPV6, tos, ttl, df,
 979			    !net_eq(tunnel->net, dev_net(dev)));
 980	iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
 981	return NETDEV_TX_OK;
 982
 983tx_error_icmp:
 984	dst_link_failure(skb);
 985tx_error:
 986	kfree_skb(skb);
 987out:
 988	dev->stats.tx_errors++;
 989	return NETDEV_TX_OK;
 990}
 991
 992static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 
 993{
 994	struct ip_tunnel *tunnel = netdev_priv(dev);
 995	const struct iphdr  *tiph = &tunnel->parms.iph;
 996
 997	skb = iptunnel_handle_offloads(skb, false, SKB_GSO_IPIP);
 998	if (IS_ERR(skb))
 999		goto out;
 
1000
1001	ip_tunnel_xmit(skb, dev, tiph, IPPROTO_IPIP);
1002	return NETDEV_TX_OK;
1003out:
 
1004	dev->stats.tx_errors++;
1005	return NETDEV_TX_OK;
1006}
1007
1008static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
1009				   struct net_device *dev)
1010{
1011	switch (skb->protocol) {
1012	case htons(ETH_P_IP):
1013		ipip_tunnel_xmit(skb, dev);
1014		break;
1015	case htons(ETH_P_IPV6):
1016		ipip6_tunnel_xmit(skb, dev);
1017		break;
 
 
 
 
 
1018	default:
1019		goto tx_err;
1020	}
1021
1022	return NETDEV_TX_OK;
1023
1024tx_err:
1025	dev->stats.tx_errors++;
1026	kfree_skb(skb);
1027	return NETDEV_TX_OK;
1028
1029}
1030
1031static void ipip6_tunnel_bind_dev(struct net_device *dev)
1032{
1033	struct net_device *tdev = NULL;
1034	struct ip_tunnel *tunnel;
1035	const struct iphdr *iph;
1036	struct flowi4 fl4;
1037
1038	tunnel = netdev_priv(dev);
1039	iph = &tunnel->parms.iph;
1040
1041	if (iph->daddr) {
1042		struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
1043							  NULL,
1044							  iph->daddr, iph->saddr,
1045							  0, 0,
1046							  IPPROTO_IPV6,
1047							  RT_TOS(iph->tos),
1048							  tunnel->parms.link);
1049
1050		if (!IS_ERR(rt)) {
1051			tdev = rt->dst.dev;
1052			ip_rt_put(rt);
1053		}
1054		dev->flags |= IFF_POINTOPOINT;
1055	}
1056
1057	if (!tdev && tunnel->parms.link)
1058		tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
1059
1060	if (tdev) {
 
 
1061		dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
1062		dev->mtu = tdev->mtu - sizeof(struct iphdr);
1063		if (dev->mtu < IPV6_MIN_MTU)
1064			dev->mtu = IPV6_MIN_MTU;
1065	}
1066	dev->iflink = tunnel->parms.link;
1067}
1068
1069static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
 
1070{
1071	struct net *net = t->net;
1072	struct sit_net *sitn = net_generic(net, sit_net_id);
1073
1074	ipip6_tunnel_unlink(sitn, t);
1075	synchronize_net();
1076	t->parms.iph.saddr = p->iph.saddr;
1077	t->parms.iph.daddr = p->iph.daddr;
1078	memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
1079	memcpy(t->dev->broadcast, &p->iph.daddr, 4);
1080	ipip6_tunnel_link(sitn, t);
1081	t->parms.iph.ttl = p->iph.ttl;
1082	t->parms.iph.tos = p->iph.tos;
1083	if (t->parms.link != p->link) {
 
1084		t->parms.link = p->link;
 
1085		ipip6_tunnel_bind_dev(t->dev);
1086	}
1087	ip_tunnel_dst_reset_all(t);
1088	netdev_state_change(t->dev);
1089}
1090
1091#ifdef CONFIG_IPV6_SIT_6RD
1092static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
1093				   struct ip_tunnel_6rd *ip6rd)
1094{
1095	struct in6_addr prefix;
1096	__be32 relay_prefix;
1097
1098	if (ip6rd->relay_prefixlen > 32 ||
1099	    ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
1100		return -EINVAL;
1101
1102	ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
1103	if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
1104		return -EINVAL;
1105	if (ip6rd->relay_prefixlen)
1106		relay_prefix = ip6rd->relay_prefix &
1107			       htonl(0xffffffffUL <<
1108				     (32 - ip6rd->relay_prefixlen));
1109	else
1110		relay_prefix = 0;
1111	if (relay_prefix != ip6rd->relay_prefix)
1112		return -EINVAL;
1113
1114	t->ip6rd.prefix = prefix;
1115	t->ip6rd.relay_prefix = relay_prefix;
1116	t->ip6rd.prefixlen = ip6rd->prefixlen;
1117	t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
1118	ip_tunnel_dst_reset_all(t);
1119	netdev_state_change(t->dev);
1120	return 0;
1121}
1122#endif
1123
 
 
 
 
 
 
 
 
 
 
1124static int
1125ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
1126{
1127	int err = 0;
1128	struct ip_tunnel_parm p;
1129	struct ip_tunnel_prl prl;
1130	struct ip_tunnel *t = netdev_priv(dev);
1131	struct net *net = t->net;
1132	struct sit_net *sitn = net_generic(net, sit_net_id);
1133#ifdef CONFIG_IPV6_SIT_6RD
1134	struct ip_tunnel_6rd ip6rd;
1135#endif
1136
1137	switch (cmd) {
1138	case SIOCGETTUNNEL:
1139#ifdef CONFIG_IPV6_SIT_6RD
1140	case SIOCGET6RD:
1141#endif
1142		if (dev == sitn->fb_tunnel_dev) {
1143			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1144				err = -EFAULT;
1145				break;
1146			}
1147			t = ipip6_tunnel_locate(net, &p, 0);
1148			if (t == NULL)
1149				t = netdev_priv(dev);
1150		}
1151
1152		err = -EFAULT;
1153		if (cmd == SIOCGETTUNNEL) {
1154			memcpy(&p, &t->parms, sizeof(p));
1155			if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
1156					 sizeof(p)))
1157				goto done;
1158#ifdef CONFIG_IPV6_SIT_6RD
1159		} else {
1160			ip6rd.prefix = t->ip6rd.prefix;
1161			ip6rd.relay_prefix = t->ip6rd.relay_prefix;
1162			ip6rd.prefixlen = t->ip6rd.prefixlen;
1163			ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
1164			if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
1165					 sizeof(ip6rd)))
1166				goto done;
1167#endif
1168		}
1169		err = 0;
1170		break;
1171
1172	case SIOCADDTUNNEL:
1173	case SIOCCHGTUNNEL:
1174		err = -EPERM;
1175		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1176			goto done;
1177
1178		err = -EFAULT;
1179		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1180			goto done;
1181
1182		err = -EINVAL;
1183		if (p.iph.protocol != IPPROTO_IPV6 &&
1184		    p.iph.protocol != IPPROTO_IPIP &&
1185		    p.iph.protocol != 0)
1186			goto done;
1187		if (p.iph.version != 4 ||
1188		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
1189			goto done;
1190		if (p.iph.ttl)
1191			p.iph.frag_off |= htons(IP_DF);
1192
1193		t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1194
1195		if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1196			if (t != NULL) {
1197				if (t->dev != dev) {
1198					err = -EEXIST;
1199					break;
1200				}
1201			} else {
1202				if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
1203				    (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
1204					err = -EINVAL;
1205					break;
1206				}
1207				t = netdev_priv(dev);
1208			}
1209
1210			ipip6_tunnel_update(t, &p);
1211		}
1212
1213		if (t) {
1214			err = 0;
1215			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1216				err = -EFAULT;
1217		} else
1218			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1219		break;
1220
1221	case SIOCDELTUNNEL:
1222		err = -EPERM;
1223		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1224			goto done;
1225
1226		if (dev == sitn->fb_tunnel_dev) {
1227			err = -EFAULT;
1228			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1229				goto done;
1230			err = -ENOENT;
1231			if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL)
 
1232				goto done;
1233			err = -EPERM;
1234			if (t == netdev_priv(sitn->fb_tunnel_dev))
1235				goto done;
1236			dev = t->dev;
1237		}
1238		unregister_netdevice(dev);
1239		err = 0;
1240		break;
1241
1242	case SIOCGETPRL:
1243		err = -EINVAL;
1244		if (dev == sitn->fb_tunnel_dev)
1245			goto done;
1246		err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
1247		break;
1248
1249	case SIOCADDPRL:
1250	case SIOCDELPRL:
1251	case SIOCCHGPRL:
1252		err = -EPERM;
1253		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1254			goto done;
1255		err = -EINVAL;
1256		if (dev == sitn->fb_tunnel_dev)
1257			goto done;
1258		err = -EFAULT;
1259		if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
1260			goto done;
1261
1262		switch (cmd) {
1263		case SIOCDELPRL:
1264			err = ipip6_tunnel_del_prl(t, &prl);
1265			break;
1266		case SIOCADDPRL:
1267		case SIOCCHGPRL:
1268			err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
1269			break;
1270		}
1271		ip_tunnel_dst_reset_all(t);
1272		netdev_state_change(dev);
1273		break;
1274
1275#ifdef CONFIG_IPV6_SIT_6RD
1276	case SIOCADD6RD:
1277	case SIOCCHG6RD:
1278	case SIOCDEL6RD:
1279		err = -EPERM;
1280		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1281			goto done;
1282
1283		err = -EFAULT;
1284		if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
1285				   sizeof(ip6rd)))
1286			goto done;
1287
1288		if (cmd != SIOCDEL6RD) {
1289			err = ipip6_tunnel_update_6rd(t, &ip6rd);
1290			if (err < 0)
1291				goto done;
1292		} else
1293			ipip6_tunnel_clone_6rd(dev, sitn);
1294
1295		err = 0;
1296		break;
1297#endif
1298
1299	default:
1300		err = -EINVAL;
1301	}
1302
1303done:
1304	return err;
1305}
1306
1307static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1308{
1309	if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
1310		return -EINVAL;
1311	dev->mtu = new_mtu;
1312	return 0;
1313}
1314
1315static const struct net_device_ops ipip6_netdev_ops = {
 
1316	.ndo_uninit	= ipip6_tunnel_uninit,
1317	.ndo_start_xmit	= sit_tunnel_xmit,
1318	.ndo_do_ioctl	= ipip6_tunnel_ioctl,
1319	.ndo_change_mtu	= ipip6_tunnel_change_mtu,
1320	.ndo_get_stats64 = ip_tunnel_get_stats64,
 
1321};
1322
1323static void ipip6_dev_free(struct net_device *dev)
1324{
1325	struct ip_tunnel *tunnel = netdev_priv(dev);
1326
1327	free_percpu(tunnel->dst_cache);
1328	free_percpu(dev->tstats);
1329	free_netdev(dev);
1330}
1331
1332#define SIT_FEATURES (NETIF_F_SG	   | \
1333		      NETIF_F_FRAGLIST	   | \
1334		      NETIF_F_HIGHDMA	   | \
1335		      NETIF_F_GSO_SOFTWARE | \
1336		      NETIF_F_HW_CSUM)
1337
1338static void ipip6_tunnel_setup(struct net_device *dev)
1339{
 
 
 
1340	dev->netdev_ops		= &ipip6_netdev_ops;
1341	dev->destructor 	= ipip6_dev_free;
 
1342
1343	dev->type		= ARPHRD_SIT;
1344	dev->hard_header_len 	= LL_MAX_HEADER + sizeof(struct iphdr);
1345	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr);
 
 
1346	dev->flags		= IFF_NOARP;
1347	dev->priv_flags	       &= ~IFF_XMIT_DST_RELEASE;
1348	dev->iflink		= 0;
1349	dev->addr_len		= 4;
1350	dev->features		|= NETIF_F_LLTX;
1351	dev->features		|= SIT_FEATURES;
1352	dev->hw_features	|= SIT_FEATURES;
1353}
1354
1355static int ipip6_tunnel_init(struct net_device *dev)
1356{
1357	struct ip_tunnel *tunnel = netdev_priv(dev);
 
1358
1359	tunnel->dev = dev;
1360	tunnel->net = dev_net(dev);
1361
1362	memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1363	memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1364
1365	ipip6_tunnel_bind_dev(dev);
1366	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1367	if (!dev->tstats)
1368		return -ENOMEM;
1369
1370	tunnel->dst_cache = alloc_percpu(struct ip_tunnel_dst);
1371	if (!tunnel->dst_cache) {
1372		free_percpu(dev->tstats);
1373		return -ENOMEM;
 
1374	}
1375
1376	return 0;
1377}
1378
1379static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
1380{
1381	struct ip_tunnel *tunnel = netdev_priv(dev);
1382	struct iphdr *iph = &tunnel->parms.iph;
1383	struct net *net = dev_net(dev);
1384	struct sit_net *sitn = net_generic(net, sit_net_id);
1385
1386	tunnel->dev = dev;
1387	tunnel->net = dev_net(dev);
1388	strcpy(tunnel->parms.name, dev->name);
1389
1390	iph->version		= 4;
1391	iph->protocol		= IPPROTO_IPV6;
1392	iph->ihl		= 5;
1393	iph->ttl		= 64;
1394
1395	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1396	if (!dev->tstats)
1397		return -ENOMEM;
1398
1399	tunnel->dst_cache = alloc_percpu(struct ip_tunnel_dst);
1400	if (!tunnel->dst_cache) {
1401		free_percpu(dev->tstats);
1402		return -ENOMEM;
1403	}
1404
1405	dev_hold(dev);
1406	rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
1407	return 0;
1408}
1409
1410static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[])
 
1411{
1412	u8 proto;
1413
1414	if (!data || !data[IFLA_IPTUN_PROTO])
1415		return 0;
1416
1417	proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1418	if (proto != IPPROTO_IPV6 &&
1419	    proto != IPPROTO_IPIP &&
1420	    proto != 0)
1421		return -EINVAL;
1422
1423	return 0;
1424}
1425
1426static void ipip6_netlink_parms(struct nlattr *data[],
1427				struct ip_tunnel_parm *parms)
 
1428{
1429	memset(parms, 0, sizeof(*parms));
1430
1431	parms->iph.version = 4;
1432	parms->iph.protocol = IPPROTO_IPV6;
1433	parms->iph.ihl = 5;
1434	parms->iph.ttl = 64;
1435
1436	if (!data)
1437		return;
1438
1439	if (data[IFLA_IPTUN_LINK])
1440		parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1441
1442	if (data[IFLA_IPTUN_LOCAL])
1443		parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
1444
1445	if (data[IFLA_IPTUN_REMOTE])
1446		parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
1447
1448	if (data[IFLA_IPTUN_TTL]) {
1449		parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
1450		if (parms->iph.ttl)
1451			parms->iph.frag_off = htons(IP_DF);
1452	}
1453
1454	if (data[IFLA_IPTUN_TOS])
1455		parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
1456
1457	if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
1458		parms->iph.frag_off = htons(IP_DF);
1459
1460	if (data[IFLA_IPTUN_FLAGS])
1461		parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
1462
1463	if (data[IFLA_IPTUN_PROTO])
1464		parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1465
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1466}
1467
1468#ifdef CONFIG_IPV6_SIT_6RD
1469/* This function returns true when 6RD attributes are present in the nl msg */
1470static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
1471				    struct ip_tunnel_6rd *ip6rd)
1472{
1473	bool ret = false;
1474	memset(ip6rd, 0, sizeof(*ip6rd));
1475
1476	if (!data)
1477		return ret;
1478
1479	if (data[IFLA_IPTUN_6RD_PREFIX]) {
1480		ret = true;
1481		nla_memcpy(&ip6rd->prefix, data[IFLA_IPTUN_6RD_PREFIX],
1482			   sizeof(struct in6_addr));
1483	}
1484
1485	if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
1486		ret = true;
1487		ip6rd->relay_prefix =
1488			nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
1489	}
1490
1491	if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
1492		ret = true;
1493		ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
1494	}
1495
1496	if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
1497		ret = true;
1498		ip6rd->relay_prefixlen =
1499			nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
1500	}
1501
1502	return ret;
1503}
1504#endif
1505
1506static int ipip6_newlink(struct net *src_net, struct net_device *dev,
1507			 struct nlattr *tb[], struct nlattr *data[])
 
1508{
1509	struct net *net = dev_net(dev);
1510	struct ip_tunnel *nt;
 
1511#ifdef CONFIG_IPV6_SIT_6RD
1512	struct ip_tunnel_6rd ip6rd;
1513#endif
1514	int err;
1515
1516	nt = netdev_priv(dev);
1517	ipip6_netlink_parms(data, &nt->parms);
 
 
 
 
 
 
 
1518
1519	if (ipip6_tunnel_locate(net, &nt->parms, 0))
1520		return -EEXIST;
1521
1522	err = ipip6_tunnel_create(dev);
1523	if (err < 0)
1524		return err;
1525
 
 
 
 
 
 
 
 
1526#ifdef CONFIG_IPV6_SIT_6RD
1527	if (ipip6_netlink_6rd_parms(data, &ip6rd))
1528		err = ipip6_tunnel_update_6rd(nt, &ip6rd);
1529#endif
1530
1531	return err;
1532}
1533
1534static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
1535			  struct nlattr *data[])
 
1536{
1537	struct ip_tunnel *t = netdev_priv(dev);
1538	struct ip_tunnel_parm p;
 
1539	struct net *net = t->net;
1540	struct sit_net *sitn = net_generic(net, sit_net_id);
1541#ifdef CONFIG_IPV6_SIT_6RD
1542	struct ip_tunnel_6rd ip6rd;
1543#endif
 
 
1544
1545	if (dev == sitn->fb_tunnel_dev)
1546		return -EINVAL;
1547
1548	ipip6_netlink_parms(data, &p);
 
 
 
 
 
 
1549
1550	if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
1551	    (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
1552		return -EINVAL;
1553
1554	t = ipip6_tunnel_locate(net, &p, 0);
1555
1556	if (t) {
1557		if (t->dev != dev)
1558			return -EEXIST;
1559	} else
1560		t = netdev_priv(dev);
1561
1562	ipip6_tunnel_update(t, &p);
1563
1564#ifdef CONFIG_IPV6_SIT_6RD
1565	if (ipip6_netlink_6rd_parms(data, &ip6rd))
1566		return ipip6_tunnel_update_6rd(t, &ip6rd);
1567#endif
1568
1569	return 0;
1570}
1571
1572static size_t ipip6_get_size(const struct net_device *dev)
1573{
1574	return
1575		/* IFLA_IPTUN_LINK */
1576		nla_total_size(4) +
1577		/* IFLA_IPTUN_LOCAL */
1578		nla_total_size(4) +
1579		/* IFLA_IPTUN_REMOTE */
1580		nla_total_size(4) +
1581		/* IFLA_IPTUN_TTL */
1582		nla_total_size(1) +
1583		/* IFLA_IPTUN_TOS */
1584		nla_total_size(1) +
1585		/* IFLA_IPTUN_PMTUDISC */
1586		nla_total_size(1) +
1587		/* IFLA_IPTUN_FLAGS */
1588		nla_total_size(2) +
1589		/* IFLA_IPTUN_PROTO */
1590		nla_total_size(1) +
1591#ifdef CONFIG_IPV6_SIT_6RD
1592		/* IFLA_IPTUN_6RD_PREFIX */
1593		nla_total_size(sizeof(struct in6_addr)) +
1594		/* IFLA_IPTUN_6RD_RELAY_PREFIX */
1595		nla_total_size(4) +
1596		/* IFLA_IPTUN_6RD_PREFIXLEN */
1597		nla_total_size(2) +
1598		/* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
1599		nla_total_size(2) +
1600#endif
 
 
 
 
 
 
 
 
 
 
1601		0;
1602}
1603
1604static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
1605{
1606	struct ip_tunnel *tunnel = netdev_priv(dev);
1607	struct ip_tunnel_parm *parm = &tunnel->parms;
1608
1609	if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1610	    nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
1611	    nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
1612	    nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
1613	    nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
1614	    nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
1615		       !!(parm->iph.frag_off & htons(IP_DF))) ||
1616	    nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
1617	    nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags))
 
1618		goto nla_put_failure;
1619
1620#ifdef CONFIG_IPV6_SIT_6RD
1621	if (nla_put(skb, IFLA_IPTUN_6RD_PREFIX, sizeof(struct in6_addr),
1622		    &tunnel->ip6rd.prefix) ||
1623	    nla_put_be32(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
1624			 tunnel->ip6rd.relay_prefix) ||
1625	    nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
1626			tunnel->ip6rd.prefixlen) ||
1627	    nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
1628			tunnel->ip6rd.relay_prefixlen))
1629		goto nla_put_failure;
1630#endif
1631
 
 
 
 
 
 
 
 
 
 
1632	return 0;
1633
1634nla_put_failure:
1635	return -EMSGSIZE;
1636}
1637
1638static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
1639	[IFLA_IPTUN_LINK]		= { .type = NLA_U32 },
1640	[IFLA_IPTUN_LOCAL]		= { .type = NLA_U32 },
1641	[IFLA_IPTUN_REMOTE]		= { .type = NLA_U32 },
1642	[IFLA_IPTUN_TTL]		= { .type = NLA_U8 },
1643	[IFLA_IPTUN_TOS]		= { .type = NLA_U8 },
1644	[IFLA_IPTUN_PMTUDISC]		= { .type = NLA_U8 },
1645	[IFLA_IPTUN_FLAGS]		= { .type = NLA_U16 },
1646	[IFLA_IPTUN_PROTO]		= { .type = NLA_U8 },
1647#ifdef CONFIG_IPV6_SIT_6RD
1648	[IFLA_IPTUN_6RD_PREFIX]		= { .len = sizeof(struct in6_addr) },
1649	[IFLA_IPTUN_6RD_RELAY_PREFIX]	= { .type = NLA_U32 },
1650	[IFLA_IPTUN_6RD_PREFIXLEN]	= { .type = NLA_U16 },
1651	[IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
1652#endif
 
 
 
 
 
1653};
1654
1655static void ipip6_dellink(struct net_device *dev, struct list_head *head)
1656{
1657	struct net *net = dev_net(dev);
1658	struct sit_net *sitn = net_generic(net, sit_net_id);
1659
1660	if (dev != sitn->fb_tunnel_dev)
1661		unregister_netdevice_queue(dev, head);
1662}
1663
1664static struct rtnl_link_ops sit_link_ops __read_mostly = {
1665	.kind		= "sit",
1666	.maxtype	= IFLA_IPTUN_MAX,
1667	.policy		= ipip6_policy,
1668	.priv_size	= sizeof(struct ip_tunnel),
1669	.setup		= ipip6_tunnel_setup,
1670	.validate	= ipip6_validate,
1671	.newlink	= ipip6_newlink,
1672	.changelink	= ipip6_changelink,
1673	.get_size	= ipip6_get_size,
1674	.fill_info	= ipip6_fill_info,
1675	.dellink	= ipip6_dellink,
 
1676};
1677
1678static struct xfrm_tunnel sit_handler __read_mostly = {
1679	.handler	=	ipip6_rcv,
1680	.err_handler	=	ipip6_err,
1681	.priority	=	1,
1682};
1683
1684static struct xfrm_tunnel ipip_handler __read_mostly = {
1685	.handler	=	ipip_rcv,
1686	.err_handler	=	ipip6_err,
1687	.priority	=	2,
1688};
1689
 
 
 
 
 
 
 
 
1690static void __net_exit sit_destroy_tunnels(struct net *net,
1691					   struct list_head *head)
1692{
1693	struct sit_net *sitn = net_generic(net, sit_net_id);
1694	struct net_device *dev, *aux;
1695	int prio;
1696
1697	for_each_netdev_safe(net, dev, aux)
1698		if (dev->rtnl_link_ops == &sit_link_ops)
1699			unregister_netdevice_queue(dev, head);
1700
1701	for (prio = 1; prio < 4; prio++) {
1702		int h;
1703		for (h = 0; h < HASH_SIZE; h++) {
1704			struct ip_tunnel *t;
1705
1706			t = rtnl_dereference(sitn->tunnels[prio][h]);
1707			while (t != NULL) {
1708				/* If dev is in the same netns, it has already
1709				 * been added to the list by the previous loop.
1710				 */
1711				if (!net_eq(dev_net(t->dev), net))
1712					unregister_netdevice_queue(t->dev,
1713								   head);
1714				t = rtnl_dereference(t->next);
1715			}
1716		}
1717	}
1718}
1719
1720static int __net_init sit_init_net(struct net *net)
1721{
1722	struct sit_net *sitn = net_generic(net, sit_net_id);
1723	struct ip_tunnel *t;
1724	int err;
1725
1726	sitn->tunnels[0] = sitn->tunnels_wc;
1727	sitn->tunnels[1] = sitn->tunnels_l;
1728	sitn->tunnels[2] = sitn->tunnels_r;
1729	sitn->tunnels[3] = sitn->tunnels_r_l;
1730
 
 
 
1731	sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
 
1732					   ipip6_tunnel_setup);
1733	if (!sitn->fb_tunnel_dev) {
1734		err = -ENOMEM;
1735		goto err_alloc_dev;
1736	}
1737	dev_net_set(sitn->fb_tunnel_dev, net);
1738	sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
1739	/* FB netdevice is special: we have one, and only one per netns.
1740	 * Allowing to move it to another netns is clearly unsafe.
1741	 */
1742	sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1743
1744	err = ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
1745	if (err)
1746		goto err_dev_free;
1747
1748	ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1749
1750	if ((err = register_netdev(sitn->fb_tunnel_dev)))
1751		goto err_reg_dev;
1752
1753	t = netdev_priv(sitn->fb_tunnel_dev);
1754
1755	strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
1756	return 0;
1757
1758err_reg_dev:
1759	dev_put(sitn->fb_tunnel_dev);
1760err_dev_free:
1761	ipip6_dev_free(sitn->fb_tunnel_dev);
1762err_alloc_dev:
1763	return err;
1764}
1765
1766static void __net_exit sit_exit_net(struct net *net)
1767{
1768	LIST_HEAD(list);
 
1769
1770	rtnl_lock();
1771	sit_destroy_tunnels(net, &list);
 
 
1772	unregister_netdevice_many(&list);
1773	rtnl_unlock();
1774}
1775
1776static struct pernet_operations sit_net_ops = {
1777	.init = sit_init_net,
1778	.exit = sit_exit_net,
1779	.id   = &sit_net_id,
1780	.size = sizeof(struct sit_net),
1781};
1782
1783static void __exit sit_cleanup(void)
1784{
1785	rtnl_link_unregister(&sit_link_ops);
1786	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1787	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
 
 
 
1788
1789	unregister_pernet_device(&sit_net_ops);
1790	rcu_barrier(); /* Wait for completion of call_rcu()'s */
1791}
1792
1793static int __init sit_init(void)
1794{
1795	int err;
1796
1797	pr_info("IPv6 over IPv4 tunneling driver\n");
1798
1799	err = register_pernet_device(&sit_net_ops);
1800	if (err < 0)
1801		return err;
1802	err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
1803	if (err < 0) {
1804		pr_info("%s: can't register ip6ip4\n", __func__);
1805		goto xfrm_tunnel_failed;
1806	}
1807	err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1808	if (err < 0) {
1809		pr_info("%s: can't register ip4ip4\n", __func__);
1810		goto xfrm_tunnel4_failed;
1811	}
 
 
 
 
 
 
 
1812	err = rtnl_link_register(&sit_link_ops);
1813	if (err < 0)
1814		goto rtnl_link_failed;
1815
1816out:
1817	return err;
1818
1819rtnl_link_failed:
 
 
 
 
1820	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1821xfrm_tunnel4_failed:
1822	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1823xfrm_tunnel_failed:
1824	unregister_pernet_device(&sit_net_ops);
1825	goto out;
1826}
1827
1828module_init(sit_init);
1829module_exit(sit_cleanup);
1830MODULE_LICENSE("GPL");
 
1831MODULE_ALIAS_NETDEV("sit0");
v4.17
   1/*
   2 *	IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
   3 *	Linux INET6 implementation
   4 *
   5 *	Authors:
   6 *	Pedro Roque		<roque@di.fc.ul.pt>
   7 *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
   8 *
   9 *	This program is free software; you can redistribute it and/or
  10 *      modify it under the terms of the GNU General Public License
  11 *      as published by the Free Software Foundation; either version
  12 *      2 of the License, or (at your option) any later version.
  13 *
  14 *	Changes:
  15 * Roger Venning <r.venning@telstra.com>:	6to4 support
  16 * Nate Thompson <nate@thebog.net>:		6to4 support
  17 * Fred Templin <fred.l.templin@boeing.com>:	isatap support
  18 */
  19
  20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22#include <linux/module.h>
  23#include <linux/capability.h>
  24#include <linux/errno.h>
  25#include <linux/types.h>
  26#include <linux/socket.h>
  27#include <linux/sockios.h>
  28#include <linux/net.h>
  29#include <linux/in6.h>
  30#include <linux/netdevice.h>
  31#include <linux/if_arp.h>
  32#include <linux/icmp.h>
  33#include <linux/slab.h>
  34#include <linux/uaccess.h>
  35#include <linux/init.h>
  36#include <linux/netfilter_ipv4.h>
  37#include <linux/if_ether.h>
  38
  39#include <net/sock.h>
  40#include <net/snmp.h>
  41
  42#include <net/ipv6.h>
  43#include <net/protocol.h>
  44#include <net/transp_v6.h>
  45#include <net/ip6_fib.h>
  46#include <net/ip6_route.h>
  47#include <net/ndisc.h>
  48#include <net/addrconf.h>
  49#include <net/ip.h>
  50#include <net/udp.h>
  51#include <net/icmp.h>
  52#include <net/ip_tunnels.h>
  53#include <net/inet_ecn.h>
  54#include <net/xfrm.h>
  55#include <net/dsfield.h>
  56#include <net/net_namespace.h>
  57#include <net/netns/generic.h>
  58
  59/*
  60   This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c
  61
  62   For comments look at net/ipv4/ip_gre.c --ANK
  63 */
  64
  65#define IP6_SIT_HASH_SIZE  16
  66#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
  67
  68static bool log_ecn_error = true;
  69module_param(log_ecn_error, bool, 0644);
  70MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  71
  72static int ipip6_tunnel_init(struct net_device *dev);
  73static void ipip6_tunnel_setup(struct net_device *dev);
  74static void ipip6_dev_free(struct net_device *dev);
  75static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
  76		      __be32 *v4dst);
  77static struct rtnl_link_ops sit_link_ops __read_mostly;
  78
  79static unsigned int sit_net_id __read_mostly;
  80struct sit_net {
  81	struct ip_tunnel __rcu *tunnels_r_l[IP6_SIT_HASH_SIZE];
  82	struct ip_tunnel __rcu *tunnels_r[IP6_SIT_HASH_SIZE];
  83	struct ip_tunnel __rcu *tunnels_l[IP6_SIT_HASH_SIZE];
  84	struct ip_tunnel __rcu *tunnels_wc[1];
  85	struct ip_tunnel __rcu **tunnels[4];
  86
  87	struct net_device *fb_tunnel_dev;
  88};
  89
  90/*
  91 * Must be invoked with rcu_read_lock
  92 */
  93static struct ip_tunnel *ipip6_tunnel_lookup(struct net *net,
  94					     struct net_device *dev,
  95					     __be32 remote, __be32 local,
  96					     int sifindex)
  97{
  98	unsigned int h0 = HASH(remote);
  99	unsigned int h1 = HASH(local);
 100	struct ip_tunnel *t;
 101	struct sit_net *sitn = net_generic(net, sit_net_id);
 102	int ifindex = dev ? dev->ifindex : 0;
 103
 104	for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) {
 105		if (local == t->parms.iph.saddr &&
 106		    remote == t->parms.iph.daddr &&
 107		    (!dev || !t->parms.link || ifindex == t->parms.link ||
 108		     sifindex == t->parms.link) &&
 109		    (t->dev->flags & IFF_UP))
 110			return t;
 111	}
 112	for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) {
 113		if (remote == t->parms.iph.daddr &&
 114		    (!dev || !t->parms.link || ifindex == t->parms.link ||
 115		     sifindex == t->parms.link) &&
 116		    (t->dev->flags & IFF_UP))
 117			return t;
 118	}
 119	for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) {
 120		if (local == t->parms.iph.saddr &&
 121		    (!dev || !t->parms.link || ifindex == t->parms.link ||
 122		     sifindex == t->parms.link) &&
 123		    (t->dev->flags & IFF_UP))
 124			return t;
 125	}
 126	t = rcu_dereference(sitn->tunnels_wc[0]);
 127	if (t && (t->dev->flags & IFF_UP))
 128		return t;
 129	return NULL;
 130}
 131
 132static struct ip_tunnel __rcu **__ipip6_bucket(struct sit_net *sitn,
 133		struct ip_tunnel_parm *parms)
 134{
 135	__be32 remote = parms->iph.daddr;
 136	__be32 local = parms->iph.saddr;
 137	unsigned int h = 0;
 138	int prio = 0;
 139
 140	if (remote) {
 141		prio |= 2;
 142		h ^= HASH(remote);
 143	}
 144	if (local) {
 145		prio |= 1;
 146		h ^= HASH(local);
 147	}
 148	return &sitn->tunnels[prio][h];
 149}
 150
 151static inline struct ip_tunnel __rcu **ipip6_bucket(struct sit_net *sitn,
 152		struct ip_tunnel *t)
 153{
 154	return __ipip6_bucket(sitn, &t->parms);
 155}
 156
 157static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t)
 158{
 159	struct ip_tunnel __rcu **tp;
 160	struct ip_tunnel *iter;
 161
 162	for (tp = ipip6_bucket(sitn, t);
 163	     (iter = rtnl_dereference(*tp)) != NULL;
 164	     tp = &iter->next) {
 165		if (t == iter) {
 166			rcu_assign_pointer(*tp, t->next);
 167			break;
 168		}
 169	}
 170}
 171
 172static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t)
 173{
 174	struct ip_tunnel __rcu **tp = ipip6_bucket(sitn, t);
 175
 176	rcu_assign_pointer(t->next, rtnl_dereference(*tp));
 177	rcu_assign_pointer(*tp, t);
 178}
 179
 180static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn)
 181{
 182#ifdef CONFIG_IPV6_SIT_6RD
 183	struct ip_tunnel *t = netdev_priv(dev);
 184
 185	if (dev == sitn->fb_tunnel_dev || !sitn->fb_tunnel_dev) {
 186		ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0);
 187		t->ip6rd.relay_prefix = 0;
 188		t->ip6rd.prefixlen = 16;
 189		t->ip6rd.relay_prefixlen = 0;
 190	} else {
 191		struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev);
 192		memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd));
 193	}
 194#endif
 195}
 196
 197static int ipip6_tunnel_create(struct net_device *dev)
 198{
 199	struct ip_tunnel *t = netdev_priv(dev);
 200	struct net *net = dev_net(dev);
 201	struct sit_net *sitn = net_generic(net, sit_net_id);
 202	int err;
 203
 204	memcpy(dev->dev_addr, &t->parms.iph.saddr, 4);
 205	memcpy(dev->broadcast, &t->parms.iph.daddr, 4);
 
 
 206
 207	if ((__force u16)t->parms.i_flags & SIT_ISATAP)
 208		dev->priv_flags |= IFF_ISATAP;
 209
 210	dev->rtnl_link_ops = &sit_link_ops;
 211
 212	err = register_netdevice(dev);
 213	if (err < 0)
 214		goto out;
 215
 216	ipip6_tunnel_clone_6rd(dev, sitn);
 
 217
 218	dev_hold(dev);
 219
 220	ipip6_tunnel_link(sitn, t);
 221	return 0;
 222
 223out:
 224	return err;
 225}
 226
 227static struct ip_tunnel *ipip6_tunnel_locate(struct net *net,
 228		struct ip_tunnel_parm *parms, int create)
 229{
 230	__be32 remote = parms->iph.daddr;
 231	__be32 local = parms->iph.saddr;
 232	struct ip_tunnel *t, *nt;
 233	struct ip_tunnel __rcu **tp;
 234	struct net_device *dev;
 235	char name[IFNAMSIZ];
 236	struct sit_net *sitn = net_generic(net, sit_net_id);
 237
 238	for (tp = __ipip6_bucket(sitn, parms);
 239	    (t = rtnl_dereference(*tp)) != NULL;
 240	     tp = &t->next) {
 241		if (local == t->parms.iph.saddr &&
 242		    remote == t->parms.iph.daddr &&
 243		    parms->link == t->parms.link) {
 244			if (create)
 245				return NULL;
 246			else
 247				return t;
 248		}
 249	}
 250	if (!create)
 251		goto failed;
 252
 253	if (parms->name[0]) {
 254		if (!dev_valid_name(parms->name))
 255			goto failed;
 256		strlcpy(name, parms->name, IFNAMSIZ);
 257	} else {
 258		strcpy(name, "sit%d");
 259	}
 260	dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
 261			   ipip6_tunnel_setup);
 262	if (!dev)
 263		return NULL;
 264
 265	dev_net_set(dev, net);
 266
 267	nt = netdev_priv(dev);
 268
 269	nt->parms = *parms;
 270	if (ipip6_tunnel_create(dev) < 0)
 271		goto failed_free;
 272
 273	return nt;
 274
 275failed_free:
 276	free_netdev(dev);
 277failed:
 278	return NULL;
 279}
 280
 281#define for_each_prl_rcu(start)			\
 282	for (prl = rcu_dereference(start);	\
 283	     prl;				\
 284	     prl = rcu_dereference(prl->next))
 285
 286static struct ip_tunnel_prl_entry *
 287__ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
 288{
 289	struct ip_tunnel_prl_entry *prl;
 290
 291	for_each_prl_rcu(t->prl)
 292		if (prl->addr == addr)
 293			break;
 294	return prl;
 295
 296}
 297
 298static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
 299				struct ip_tunnel_prl __user *a)
 300{
 301	struct ip_tunnel_prl kprl, *kp;
 302	struct ip_tunnel_prl_entry *prl;
 303	unsigned int cmax, c = 0, ca, len;
 304	int ret = 0;
 305
 306	if (copy_from_user(&kprl, a, sizeof(kprl)))
 307		return -EFAULT;
 308	cmax = kprl.datalen / sizeof(kprl);
 309	if (cmax > 1 && kprl.addr != htonl(INADDR_ANY))
 310		cmax = 1;
 311
 312	/* For simple GET or for root users,
 313	 * we try harder to allocate.
 314	 */
 315	kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
 316		kcalloc(cmax, sizeof(*kp), GFP_KERNEL | __GFP_NOWARN) :
 317		NULL;
 318
 319	rcu_read_lock();
 320
 321	ca = t->prl_count < cmax ? t->prl_count : cmax;
 322
 323	if (!kp) {
 324		/* We don't try hard to allocate much memory for
 325		 * non-root users.
 326		 * For root users, retry allocating enough memory for
 327		 * the answer.
 328		 */
 329		kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC);
 330		if (!kp) {
 331			ret = -ENOMEM;
 332			goto out;
 333		}
 334	}
 335
 336	c = 0;
 337	for_each_prl_rcu(t->prl) {
 338		if (c >= cmax)
 339			break;
 340		if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
 341			continue;
 342		kp[c].addr = prl->addr;
 343		kp[c].flags = prl->flags;
 344		c++;
 345		if (kprl.addr != htonl(INADDR_ANY))
 346			break;
 347	}
 348out:
 349	rcu_read_unlock();
 350
 351	len = sizeof(*kp) * c;
 352	ret = 0;
 353	if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
 354		ret = -EFAULT;
 355
 356	kfree(kp);
 357
 358	return ret;
 359}
 360
 361static int
 362ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
 363{
 364	struct ip_tunnel_prl_entry *p;
 365	int err = 0;
 366
 367	if (a->addr == htonl(INADDR_ANY))
 368		return -EINVAL;
 369
 370	ASSERT_RTNL();
 371
 372	for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) {
 373		if (p->addr == a->addr) {
 374			if (chg) {
 375				p->flags = a->flags;
 376				goto out;
 377			}
 378			err = -EEXIST;
 379			goto out;
 380		}
 381	}
 382
 383	if (chg) {
 384		err = -ENXIO;
 385		goto out;
 386	}
 387
 388	p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
 389	if (!p) {
 390		err = -ENOBUFS;
 391		goto out;
 392	}
 393
 394	p->next = t->prl;
 395	p->addr = a->addr;
 396	p->flags = a->flags;
 397	t->prl_count++;
 398	rcu_assign_pointer(t->prl, p);
 399out:
 400	return err;
 401}
 402
 403static void prl_list_destroy_rcu(struct rcu_head *head)
 404{
 405	struct ip_tunnel_prl_entry *p, *n;
 406
 407	p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
 408	do {
 409		n = rcu_dereference_protected(p->next, 1);
 410		kfree(p);
 411		p = n;
 412	} while (p);
 413}
 414
 415static int
 416ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
 417{
 418	struct ip_tunnel_prl_entry *x;
 419	struct ip_tunnel_prl_entry __rcu **p;
 420	int err = 0;
 421
 422	ASSERT_RTNL();
 423
 424	if (a && a->addr != htonl(INADDR_ANY)) {
 425		for (p = &t->prl;
 426		     (x = rtnl_dereference(*p)) != NULL;
 427		     p = &x->next) {
 428			if (x->addr == a->addr) {
 429				*p = x->next;
 430				kfree_rcu(x, rcu_head);
 431				t->prl_count--;
 432				goto out;
 433			}
 434		}
 435		err = -ENXIO;
 436	} else {
 437		x = rtnl_dereference(t->prl);
 438		if (x) {
 439			t->prl_count = 0;
 440			call_rcu(&x->rcu_head, prl_list_destroy_rcu);
 441			t->prl = NULL;
 442		}
 443	}
 444out:
 445	return err;
 446}
 447
 448static int
 449isatap_chksrc(struct sk_buff *skb, const struct iphdr *iph, struct ip_tunnel *t)
 450{
 451	struct ip_tunnel_prl_entry *p;
 452	int ok = 1;
 453
 454	rcu_read_lock();
 455	p = __ipip6_tunnel_locate_prl(t, iph->saddr);
 456	if (p) {
 457		if (p->flags & PRL_DEFAULT)
 458			skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
 459		else
 460			skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
 461	} else {
 462		const struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;
 463
 464		if (ipv6_addr_is_isatap(addr6) &&
 465		    (addr6->s6_addr32[3] == iph->saddr) &&
 466		    ipv6_chk_prefix(addr6, t->dev))
 467			skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
 468		else
 469			ok = 0;
 470	}
 471	rcu_read_unlock();
 472	return ok;
 473}
 474
 475static void ipip6_tunnel_uninit(struct net_device *dev)
 476{
 477	struct ip_tunnel *tunnel = netdev_priv(dev);
 478	struct sit_net *sitn = net_generic(tunnel->net, sit_net_id);
 479
 480	if (dev == sitn->fb_tunnel_dev) {
 481		RCU_INIT_POINTER(sitn->tunnels_wc[0], NULL);
 482	} else {
 483		ipip6_tunnel_unlink(sitn, tunnel);
 484		ipip6_tunnel_del_prl(tunnel, NULL);
 485	}
 486	dst_cache_reset(&tunnel->dst_cache);
 487	dev_put(dev);
 488}
 489
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 490static int ipip6_err(struct sk_buff *skb, u32 info)
 491{
 492	const struct iphdr *iph = (const struct iphdr *)skb->data;
 493	const int type = icmp_hdr(skb)->type;
 494	const int code = icmp_hdr(skb)->code;
 495	unsigned int data_len = 0;
 496	struct ip_tunnel *t;
 497	int sifindex;
 498	int err;
 499
 500	switch (type) {
 501	default:
 502	case ICMP_PARAMETERPROB:
 503		return 0;
 504
 505	case ICMP_DEST_UNREACH:
 506		switch (code) {
 507		case ICMP_SR_FAILED:
 508			/* Impossible event. */
 509			return 0;
 510		default:
 511			/* All others are translated to HOST_UNREACH.
 512			   rfc2003 contains "deep thoughts" about NET_UNREACH,
 513			   I believe they are just ether pollution. --ANK
 514			 */
 515			break;
 516		}
 517		break;
 518	case ICMP_TIME_EXCEEDED:
 519		if (code != ICMP_EXC_TTL)
 520			return 0;
 521		data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
 522		break;
 523	case ICMP_REDIRECT:
 524		break;
 525	}
 526
 527	err = -ENOENT;
 528
 529	sifindex = netif_is_l3_master(skb->dev) ? IPCB(skb)->iif : 0;
 530	t = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
 531				iph->daddr, iph->saddr, sifindex);
 532	if (!t)
 
 533		goto out;
 534
 535	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 536		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 537				 t->parms.link, 0, iph->protocol, 0);
 538		err = 0;
 539		goto out;
 540	}
 541	if (type == ICMP_REDIRECT) {
 542		ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
 543			      iph->protocol, 0);
 544		err = 0;
 545		goto out;
 546	}
 547
 548	err = 0;
 549	if (!ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4, type, data_len))
 550		goto out;
 551
 552	if (t->parms.iph.daddr == 0)
 
 553		goto out;
 554
 555	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 556		goto out;
 557
 558	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 559		t->err_count++;
 560	else
 561		t->err_count = 1;
 562	t->err_time = jiffies;
 563out:
 564	return err;
 565}
 566
 567static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
 568				  const struct in6_addr *v6addr)
 569{
 570	__be32 v4embed = 0;
 571	if (check_6rd(tunnel, v6addr, &v4embed) && v4addr != v4embed)
 572		return true;
 573	return false;
 574}
 575
 576/* Checks if an address matches an address on the tunnel interface.
 577 * Used to detect the NAT of proto 41 packets and let them pass spoofing test.
 578 * Long story:
 579 * This function is called after we considered the packet as spoofed
 580 * in is_spoofed_6rd.
 581 * We may have a router that is doing NAT for proto 41 packets
 582 * for an internal station. Destination a.a.a.a/PREFIX:bbbb:bbbb
 583 * will be translated to n.n.n.n/PREFIX:bbbb:bbbb. And is_spoofed_6rd
 584 * function will return true, dropping the packet.
 585 * But, we can still check if is spoofed against the IP
 586 * addresses associated with the interface.
 587 */
 588static bool only_dnatted(const struct ip_tunnel *tunnel,
 589	const struct in6_addr *v6dst)
 590{
 591	int prefix_len;
 592
 593#ifdef CONFIG_IPV6_SIT_6RD
 594	prefix_len = tunnel->ip6rd.prefixlen + 32
 595		- tunnel->ip6rd.relay_prefixlen;
 596#else
 597	prefix_len = 48;
 598#endif
 599	return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
 600}
 601
 602/* Returns true if a packet is spoofed */
 603static bool packet_is_spoofed(struct sk_buff *skb,
 604			      const struct iphdr *iph,
 605			      struct ip_tunnel *tunnel)
 606{
 607	const struct ipv6hdr *ipv6h;
 608
 609	if (tunnel->dev->priv_flags & IFF_ISATAP) {
 610		if (!isatap_chksrc(skb, iph, tunnel))
 611			return true;
 612
 613		return false;
 614	}
 615
 616	if (tunnel->dev->flags & IFF_POINTOPOINT)
 617		return false;
 618
 619	ipv6h = ipv6_hdr(skb);
 620
 621	if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
 622		net_warn_ratelimited("Src spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
 623				     &iph->saddr, &ipv6h->saddr,
 624				     &iph->daddr, &ipv6h->daddr);
 625		return true;
 626	}
 627
 628	if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
 629		return false;
 630
 631	if (only_dnatted(tunnel, &ipv6h->daddr))
 632		return false;
 633
 634	net_warn_ratelimited("Dst spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
 635			     &iph->saddr, &ipv6h->saddr,
 636			     &iph->daddr, &ipv6h->daddr);
 637	return true;
 638}
 639
 640static int ipip6_rcv(struct sk_buff *skb)
 641{
 642	const struct iphdr *iph = ip_hdr(skb);
 643	struct ip_tunnel *tunnel;
 644	int sifindex;
 645	int err;
 646
 647	sifindex = netif_is_l3_master(skb->dev) ? IPCB(skb)->iif : 0;
 648	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
 649				     iph->saddr, iph->daddr, sifindex);
 650	if (tunnel) {
 651		struct pcpu_sw_netstats *tstats;
 652
 653		if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
 654		    tunnel->parms.iph.protocol != 0)
 655			goto out;
 656
 657		skb->mac_header = skb->network_header;
 658		skb_reset_network_header(skb);
 659		IPCB(skb)->flags = 0;
 660		skb->dev = tunnel->dev;
 661
 662		if (packet_is_spoofed(skb, iph, tunnel)) {
 663			tunnel->dev->stats.rx_errors++;
 664			goto out;
 665		}
 666
 667		if (iptunnel_pull_header(skb, 0, htons(ETH_P_IPV6),
 668		    !net_eq(tunnel->net, dev_net(tunnel->dev))))
 669			goto out;
 670
 671		err = IP_ECN_decapsulate(iph, skb);
 672		if (unlikely(err)) {
 673			if (log_ecn_error)
 674				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
 675						     &iph->saddr, iph->tos);
 676			if (err > 1) {
 677				++tunnel->dev->stats.rx_frame_errors;
 678				++tunnel->dev->stats.rx_errors;
 679				goto out;
 680			}
 681		}
 682
 683		tstats = this_cpu_ptr(tunnel->dev->tstats);
 684		u64_stats_update_begin(&tstats->syncp);
 685		tstats->rx_packets++;
 686		tstats->rx_bytes += skb->len;
 687		u64_stats_update_end(&tstats->syncp);
 688
 689		netif_rx(skb);
 690
 691		return 0;
 692	}
 693
 694	/* no tunnel matched,  let upstream know, ipsec may handle it */
 695	return 1;
 696out:
 697	kfree_skb(skb);
 698	return 0;
 699}
 700
 701static const struct tnl_ptk_info ipip_tpi = {
 702	/* no tunnel info required for ipip. */
 703	.proto = htons(ETH_P_IP),
 704};
 705
 706#if IS_ENABLED(CONFIG_MPLS)
 707static const struct tnl_ptk_info mplsip_tpi = {
 708	/* no tunnel info required for mplsip. */
 709	.proto = htons(ETH_P_MPLS_UC),
 710};
 711#endif
 712
 713static int sit_tunnel_rcv(struct sk_buff *skb, u8 ipproto)
 714{
 715	const struct iphdr *iph;
 716	struct ip_tunnel *tunnel;
 717	int sifindex;
 718
 719	sifindex = netif_is_l3_master(skb->dev) ? IPCB(skb)->iif : 0;
 720
 721	iph = ip_hdr(skb);
 722	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
 723				     iph->saddr, iph->daddr, sifindex);
 724	if (tunnel) {
 725		const struct tnl_ptk_info *tpi;
 726
 727		if (tunnel->parms.iph.protocol != ipproto &&
 728		    tunnel->parms.iph.protocol != 0)
 729			goto drop;
 730
 731		if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 732			goto drop;
 733#if IS_ENABLED(CONFIG_MPLS)
 734		if (ipproto == IPPROTO_MPLS)
 735			tpi = &mplsip_tpi;
 736		else
 737#endif
 738			tpi = &ipip_tpi;
 739		if (iptunnel_pull_header(skb, 0, tpi->proto, false))
 740			goto drop;
 741		return ip_tunnel_rcv(tunnel, skb, tpi, NULL, log_ecn_error);
 742	}
 743
 744	return 1;
 745
 746drop:
 747	kfree_skb(skb);
 748	return 0;
 749}
 750
 751static int ipip_rcv(struct sk_buff *skb)
 752{
 753	return sit_tunnel_rcv(skb, IPPROTO_IPIP);
 754}
 755
 756#if IS_ENABLED(CONFIG_MPLS)
 757static int mplsip_rcv(struct sk_buff *skb)
 758{
 759	return sit_tunnel_rcv(skb, IPPROTO_MPLS);
 760}
 761#endif
 762
 763/*
 764 * If the IPv6 address comes from 6rd / 6to4 (RFC 3056) addr space this function
 765 * stores the embedded IPv4 address in v4dst and returns true.
 766 */
 767static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
 768		      __be32 *v4dst)
 769{
 770#ifdef CONFIG_IPV6_SIT_6RD
 771	if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
 772			      tunnel->ip6rd.prefixlen)) {
 773		unsigned int pbw0, pbi0;
 774		int pbi1;
 775		u32 d;
 776
 777		pbw0 = tunnel->ip6rd.prefixlen >> 5;
 778		pbi0 = tunnel->ip6rd.prefixlen & 0x1f;
 779
 780		d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
 781		    tunnel->ip6rd.relay_prefixlen;
 782
 783		pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
 784		if (pbi1 > 0)
 785			d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
 786			     (32 - pbi1);
 787
 788		*v4dst = tunnel->ip6rd.relay_prefix | htonl(d);
 789		return true;
 790	}
 791#else
 792	if (v6dst->s6_addr16[0] == htons(0x2002)) {
 793		/* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
 794		memcpy(v4dst, &v6dst->s6_addr16[1], 4);
 795		return true;
 796	}
 797#endif
 798	return false;
 799}
 800
 801static inline __be32 try_6rd(struct ip_tunnel *tunnel,
 802			     const struct in6_addr *v6dst)
 803{
 804	__be32 dst = 0;
 805	check_6rd(tunnel, v6dst, &dst);
 806	return dst;
 807}
 808
 809/*
 810 *	This function assumes it is being called from dev_queue_xmit()
 811 *	and that skb is filled properly by that function.
 812 */
 813
 814static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
 815				     struct net_device *dev)
 816{
 817	struct ip_tunnel *tunnel = netdev_priv(dev);
 818	const struct iphdr  *tiph = &tunnel->parms.iph;
 819	const struct ipv6hdr *iph6 = ipv6_hdr(skb);
 820	u8     tos = tunnel->parms.iph.tos;
 821	__be16 df = tiph->frag_off;
 822	struct rtable *rt;		/* Route to the other host */
 823	struct net_device *tdev;	/* Device to other host */
 824	unsigned int max_headroom;	/* The extra header space needed */
 825	__be32 dst = tiph->daddr;
 826	struct flowi4 fl4;
 827	int    mtu;
 828	const struct in6_addr *addr6;
 829	int addr_type;
 830	u8 ttl;
 831	u8 protocol = IPPROTO_IPV6;
 832	int t_hlen = tunnel->hlen + sizeof(struct iphdr);
 
 
 833
 834	if (tos == 1)
 835		tos = ipv6_get_dsfield(iph6);
 836
 837	/* ISATAP (RFC4214) - must come before 6to4 */
 838	if (dev->priv_flags & IFF_ISATAP) {
 839		struct neighbour *neigh = NULL;
 840		bool do_tx_error = false;
 841
 842		if (skb_dst(skb))
 843			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
 844
 845		if (!neigh) {
 846			net_dbg_ratelimited("nexthop == NULL\n");
 847			goto tx_error;
 848		}
 849
 850		addr6 = (const struct in6_addr *)&neigh->primary_key;
 851		addr_type = ipv6_addr_type(addr6);
 852
 853		if ((addr_type & IPV6_ADDR_UNICAST) &&
 854		     ipv6_addr_is_isatap(addr6))
 855			dst = addr6->s6_addr32[3];
 856		else
 857			do_tx_error = true;
 858
 859		neigh_release(neigh);
 860		if (do_tx_error)
 861			goto tx_error;
 862	}
 863
 864	if (!dst)
 865		dst = try_6rd(tunnel, &iph6->daddr);
 866
 867	if (!dst) {
 868		struct neighbour *neigh = NULL;
 869		bool do_tx_error = false;
 870
 871		if (skb_dst(skb))
 872			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
 873
 874		if (!neigh) {
 875			net_dbg_ratelimited("nexthop == NULL\n");
 876			goto tx_error;
 877		}
 878
 879		addr6 = (const struct in6_addr *)&neigh->primary_key;
 880		addr_type = ipv6_addr_type(addr6);
 881
 882		if (addr_type == IPV6_ADDR_ANY) {
 883			addr6 = &ipv6_hdr(skb)->daddr;
 884			addr_type = ipv6_addr_type(addr6);
 885		}
 886
 887		if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
 888			dst = addr6->s6_addr32[3];
 889		else
 890			do_tx_error = true;
 891
 892		neigh_release(neigh);
 893		if (do_tx_error)
 894			goto tx_error;
 895	}
 896
 897	flowi4_init_output(&fl4, tunnel->parms.link, tunnel->fwmark,
 898			   RT_TOS(tos), RT_SCOPE_UNIVERSE, IPPROTO_IPV6,
 899			   0, dst, tiph->saddr, 0, 0,
 900			   sock_net_uid(tunnel->net, NULL));
 901	rt = ip_route_output_flow(tunnel->net, &fl4, NULL);
 902
 903	if (IS_ERR(rt)) {
 904		dev->stats.tx_carrier_errors++;
 905		goto tx_error_icmp;
 906	}
 907	if (rt->rt_type != RTN_UNICAST) {
 908		ip_rt_put(rt);
 909		dev->stats.tx_carrier_errors++;
 910		goto tx_error_icmp;
 911	}
 912	tdev = rt->dst.dev;
 913
 914	if (tdev == dev) {
 915		ip_rt_put(rt);
 916		dev->stats.collisions++;
 917		goto tx_error;
 918	}
 919
 920	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4)) {
 921		ip_rt_put(rt);
 922		goto tx_error;
 923	}
 924
 925	if (df) {
 926		mtu = dst_mtu(&rt->dst) - t_hlen;
 927
 928		if (mtu < 68) {
 929			dev->stats.collisions++;
 930			ip_rt_put(rt);
 931			goto tx_error;
 932		}
 933
 934		if (mtu < IPV6_MIN_MTU) {
 935			mtu = IPV6_MIN_MTU;
 936			df = 0;
 937		}
 938
 939		if (tunnel->parms.iph.daddr)
 940			skb_dst_update_pmtu(skb, mtu);
 941
 942		if (skb->len > mtu && !skb_is_gso(skb)) {
 943			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
 944			ip_rt_put(rt);
 945			goto tx_error;
 946		}
 947	}
 948
 949	if (tunnel->err_count > 0) {
 950		if (time_before(jiffies,
 951				tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
 952			tunnel->err_count--;
 953			dst_link_failure(skb);
 954		} else
 955			tunnel->err_count = 0;
 956	}
 957
 958	/*
 959	 * Okay, now see if we can stuff it in the buffer as-is.
 960	 */
 961	max_headroom = LL_RESERVED_SPACE(tdev) + t_hlen;
 962
 963	if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
 964	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
 965		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 966		if (!new_skb) {
 967			ip_rt_put(rt);
 968			dev->stats.tx_dropped++;
 969			kfree_skb(skb);
 970			return NETDEV_TX_OK;
 971		}
 972		if (skb->sk)
 973			skb_set_owner_w(new_skb, skb->sk);
 974		dev_kfree_skb(skb);
 975		skb = new_skb;
 976		iph6 = ipv6_hdr(skb);
 977	}
 978	ttl = tiph->ttl;
 979	if (ttl == 0)
 980		ttl = iph6->hop_limit;
 981	tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
 982
 983	if (ip_tunnel_encap(skb, tunnel, &protocol, &fl4) < 0) {
 
 984		ip_rt_put(rt);
 985		goto tx_error;
 986	}
 987
 988	skb_set_inner_ipproto(skb, IPPROTO_IPV6);
 989
 990	iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, protocol, tos, ttl,
 991		      df, !net_eq(tunnel->net, dev_net(dev)));
 992	return NETDEV_TX_OK;
 993
 994tx_error_icmp:
 995	dst_link_failure(skb);
 996tx_error:
 997	kfree_skb(skb);
 
 998	dev->stats.tx_errors++;
 999	return NETDEV_TX_OK;
1000}
1001
1002static netdev_tx_t sit_tunnel_xmit__(struct sk_buff *skb,
1003				     struct net_device *dev, u8 ipproto)
1004{
1005	struct ip_tunnel *tunnel = netdev_priv(dev);
1006	const struct iphdr  *tiph = &tunnel->parms.iph;
1007
1008	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4))
1009		goto tx_error;
1010
1011	skb_set_inner_ipproto(skb, ipproto);
1012
1013	ip_tunnel_xmit(skb, dev, tiph, ipproto);
1014	return NETDEV_TX_OK;
1015tx_error:
1016	kfree_skb(skb);
1017	dev->stats.tx_errors++;
1018	return NETDEV_TX_OK;
1019}
1020
1021static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
1022				   struct net_device *dev)
1023{
1024	switch (skb->protocol) {
1025	case htons(ETH_P_IP):
1026		sit_tunnel_xmit__(skb, dev, IPPROTO_IPIP);
1027		break;
1028	case htons(ETH_P_IPV6):
1029		ipip6_tunnel_xmit(skb, dev);
1030		break;
1031#if IS_ENABLED(CONFIG_MPLS)
1032	case htons(ETH_P_MPLS_UC):
1033		sit_tunnel_xmit__(skb, dev, IPPROTO_MPLS);
1034		break;
1035#endif
1036	default:
1037		goto tx_err;
1038	}
1039
1040	return NETDEV_TX_OK;
1041
1042tx_err:
1043	dev->stats.tx_errors++;
1044	kfree_skb(skb);
1045	return NETDEV_TX_OK;
1046
1047}
1048
1049static void ipip6_tunnel_bind_dev(struct net_device *dev)
1050{
1051	struct net_device *tdev = NULL;
1052	struct ip_tunnel *tunnel;
1053	const struct iphdr *iph;
1054	struct flowi4 fl4;
1055
1056	tunnel = netdev_priv(dev);
1057	iph = &tunnel->parms.iph;
1058
1059	if (iph->daddr) {
1060		struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
1061							  NULL,
1062							  iph->daddr, iph->saddr,
1063							  0, 0,
1064							  IPPROTO_IPV6,
1065							  RT_TOS(iph->tos),
1066							  tunnel->parms.link);
1067
1068		if (!IS_ERR(rt)) {
1069			tdev = rt->dst.dev;
1070			ip_rt_put(rt);
1071		}
1072		dev->flags |= IFF_POINTOPOINT;
1073	}
1074
1075	if (!tdev && tunnel->parms.link)
1076		tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
1077
1078	if (tdev) {
1079		int t_hlen = tunnel->hlen + sizeof(struct iphdr);
1080
1081		dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
1082		dev->mtu = tdev->mtu - t_hlen;
1083		if (dev->mtu < IPV6_MIN_MTU)
1084			dev->mtu = IPV6_MIN_MTU;
1085	}
 
1086}
1087
1088static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p,
1089				__u32 fwmark)
1090{
1091	struct net *net = t->net;
1092	struct sit_net *sitn = net_generic(net, sit_net_id);
1093
1094	ipip6_tunnel_unlink(sitn, t);
1095	synchronize_net();
1096	t->parms.iph.saddr = p->iph.saddr;
1097	t->parms.iph.daddr = p->iph.daddr;
1098	memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
1099	memcpy(t->dev->broadcast, &p->iph.daddr, 4);
1100	ipip6_tunnel_link(sitn, t);
1101	t->parms.iph.ttl = p->iph.ttl;
1102	t->parms.iph.tos = p->iph.tos;
1103	t->parms.iph.frag_off = p->iph.frag_off;
1104	if (t->parms.link != p->link || t->fwmark != fwmark) {
1105		t->parms.link = p->link;
1106		t->fwmark = fwmark;
1107		ipip6_tunnel_bind_dev(t->dev);
1108	}
1109	dst_cache_reset(&t->dst_cache);
1110	netdev_state_change(t->dev);
1111}
1112
1113#ifdef CONFIG_IPV6_SIT_6RD
1114static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
1115				   struct ip_tunnel_6rd *ip6rd)
1116{
1117	struct in6_addr prefix;
1118	__be32 relay_prefix;
1119
1120	if (ip6rd->relay_prefixlen > 32 ||
1121	    ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
1122		return -EINVAL;
1123
1124	ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
1125	if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
1126		return -EINVAL;
1127	if (ip6rd->relay_prefixlen)
1128		relay_prefix = ip6rd->relay_prefix &
1129			       htonl(0xffffffffUL <<
1130				     (32 - ip6rd->relay_prefixlen));
1131	else
1132		relay_prefix = 0;
1133	if (relay_prefix != ip6rd->relay_prefix)
1134		return -EINVAL;
1135
1136	t->ip6rd.prefix = prefix;
1137	t->ip6rd.relay_prefix = relay_prefix;
1138	t->ip6rd.prefixlen = ip6rd->prefixlen;
1139	t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
1140	dst_cache_reset(&t->dst_cache);
1141	netdev_state_change(t->dev);
1142	return 0;
1143}
1144#endif
1145
1146static bool ipip6_valid_ip_proto(u8 ipproto)
1147{
1148	return ipproto == IPPROTO_IPV6 ||
1149		ipproto == IPPROTO_IPIP ||
1150#if IS_ENABLED(CONFIG_MPLS)
1151		ipproto == IPPROTO_MPLS ||
1152#endif
1153		ipproto == 0;
1154}
1155
1156static int
1157ipip6_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1158{
1159	int err = 0;
1160	struct ip_tunnel_parm p;
1161	struct ip_tunnel_prl prl;
1162	struct ip_tunnel *t = netdev_priv(dev);
1163	struct net *net = t->net;
1164	struct sit_net *sitn = net_generic(net, sit_net_id);
1165#ifdef CONFIG_IPV6_SIT_6RD
1166	struct ip_tunnel_6rd ip6rd;
1167#endif
1168
1169	switch (cmd) {
1170	case SIOCGETTUNNEL:
1171#ifdef CONFIG_IPV6_SIT_6RD
1172	case SIOCGET6RD:
1173#endif
1174		if (dev == sitn->fb_tunnel_dev) {
1175			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1176				err = -EFAULT;
1177				break;
1178			}
1179			t = ipip6_tunnel_locate(net, &p, 0);
1180			if (!t)
1181				t = netdev_priv(dev);
1182		}
1183
1184		err = -EFAULT;
1185		if (cmd == SIOCGETTUNNEL) {
1186			memcpy(&p, &t->parms, sizeof(p));
1187			if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
1188					 sizeof(p)))
1189				goto done;
1190#ifdef CONFIG_IPV6_SIT_6RD
1191		} else {
1192			ip6rd.prefix = t->ip6rd.prefix;
1193			ip6rd.relay_prefix = t->ip6rd.relay_prefix;
1194			ip6rd.prefixlen = t->ip6rd.prefixlen;
1195			ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
1196			if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
1197					 sizeof(ip6rd)))
1198				goto done;
1199#endif
1200		}
1201		err = 0;
1202		break;
1203
1204	case SIOCADDTUNNEL:
1205	case SIOCCHGTUNNEL:
1206		err = -EPERM;
1207		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1208			goto done;
1209
1210		err = -EFAULT;
1211		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1212			goto done;
1213
1214		err = -EINVAL;
1215		if (!ipip6_valid_ip_proto(p.iph.protocol))
 
 
1216			goto done;
1217		if (p.iph.version != 4 ||
1218		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
1219			goto done;
1220		if (p.iph.ttl)
1221			p.iph.frag_off |= htons(IP_DF);
1222
1223		t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1224
1225		if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1226			if (t) {
1227				if (t->dev != dev) {
1228					err = -EEXIST;
1229					break;
1230				}
1231			} else {
1232				if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
1233				    (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
1234					err = -EINVAL;
1235					break;
1236				}
1237				t = netdev_priv(dev);
1238			}
1239
1240			ipip6_tunnel_update(t, &p, t->fwmark);
1241		}
1242
1243		if (t) {
1244			err = 0;
1245			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1246				err = -EFAULT;
1247		} else
1248			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1249		break;
1250
1251	case SIOCDELTUNNEL:
1252		err = -EPERM;
1253		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1254			goto done;
1255
1256		if (dev == sitn->fb_tunnel_dev) {
1257			err = -EFAULT;
1258			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1259				goto done;
1260			err = -ENOENT;
1261			t = ipip6_tunnel_locate(net, &p, 0);
1262			if (!t)
1263				goto done;
1264			err = -EPERM;
1265			if (t == netdev_priv(sitn->fb_tunnel_dev))
1266				goto done;
1267			dev = t->dev;
1268		}
1269		unregister_netdevice(dev);
1270		err = 0;
1271		break;
1272
1273	case SIOCGETPRL:
1274		err = -EINVAL;
1275		if (dev == sitn->fb_tunnel_dev)
1276			goto done;
1277		err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
1278		break;
1279
1280	case SIOCADDPRL:
1281	case SIOCDELPRL:
1282	case SIOCCHGPRL:
1283		err = -EPERM;
1284		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1285			goto done;
1286		err = -EINVAL;
1287		if (dev == sitn->fb_tunnel_dev)
1288			goto done;
1289		err = -EFAULT;
1290		if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
1291			goto done;
1292
1293		switch (cmd) {
1294		case SIOCDELPRL:
1295			err = ipip6_tunnel_del_prl(t, &prl);
1296			break;
1297		case SIOCADDPRL:
1298		case SIOCCHGPRL:
1299			err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
1300			break;
1301		}
1302		dst_cache_reset(&t->dst_cache);
1303		netdev_state_change(dev);
1304		break;
1305
1306#ifdef CONFIG_IPV6_SIT_6RD
1307	case SIOCADD6RD:
1308	case SIOCCHG6RD:
1309	case SIOCDEL6RD:
1310		err = -EPERM;
1311		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1312			goto done;
1313
1314		err = -EFAULT;
1315		if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
1316				   sizeof(ip6rd)))
1317			goto done;
1318
1319		if (cmd != SIOCDEL6RD) {
1320			err = ipip6_tunnel_update_6rd(t, &ip6rd);
1321			if (err < 0)
1322				goto done;
1323		} else
1324			ipip6_tunnel_clone_6rd(dev, sitn);
1325
1326		err = 0;
1327		break;
1328#endif
1329
1330	default:
1331		err = -EINVAL;
1332	}
1333
1334done:
1335	return err;
1336}
1337
 
 
 
 
 
 
 
 
1338static const struct net_device_ops ipip6_netdev_ops = {
1339	.ndo_init	= ipip6_tunnel_init,
1340	.ndo_uninit	= ipip6_tunnel_uninit,
1341	.ndo_start_xmit	= sit_tunnel_xmit,
1342	.ndo_do_ioctl	= ipip6_tunnel_ioctl,
 
1343	.ndo_get_stats64 = ip_tunnel_get_stats64,
1344	.ndo_get_iflink = ip_tunnel_get_iflink,
1345};
1346
1347static void ipip6_dev_free(struct net_device *dev)
1348{
1349	struct ip_tunnel *tunnel = netdev_priv(dev);
1350
1351	dst_cache_destroy(&tunnel->dst_cache);
1352	free_percpu(dev->tstats);
 
1353}
1354
1355#define SIT_FEATURES (NETIF_F_SG	   | \
1356		      NETIF_F_FRAGLIST	   | \
1357		      NETIF_F_HIGHDMA	   | \
1358		      NETIF_F_GSO_SOFTWARE | \
1359		      NETIF_F_HW_CSUM)
1360
1361static void ipip6_tunnel_setup(struct net_device *dev)
1362{
1363	struct ip_tunnel *tunnel = netdev_priv(dev);
1364	int t_hlen = tunnel->hlen + sizeof(struct iphdr);
1365
1366	dev->netdev_ops		= &ipip6_netdev_ops;
1367	dev->needs_free_netdev	= true;
1368	dev->priv_destructor	= ipip6_dev_free;
1369
1370	dev->type		= ARPHRD_SIT;
1371	dev->hard_header_len	= LL_MAX_HEADER + t_hlen;
1372	dev->mtu		= ETH_DATA_LEN - t_hlen;
1373	dev->min_mtu		= IPV6_MIN_MTU;
1374	dev->max_mtu		= IP6_MAX_MTU - t_hlen;
1375	dev->flags		= IFF_NOARP;
1376	netif_keep_dst(dev);
 
1377	dev->addr_len		= 4;
1378	dev->features		|= NETIF_F_LLTX;
1379	dev->features		|= SIT_FEATURES;
1380	dev->hw_features	|= SIT_FEATURES;
1381}
1382
1383static int ipip6_tunnel_init(struct net_device *dev)
1384{
1385	struct ip_tunnel *tunnel = netdev_priv(dev);
1386	int err;
1387
1388	tunnel->dev = dev;
1389	tunnel->net = dev_net(dev);
1390	strcpy(tunnel->parms.name, dev->name);
 
 
1391
1392	ipip6_tunnel_bind_dev(dev);
1393	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1394	if (!dev->tstats)
1395		return -ENOMEM;
1396
1397	err = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
1398	if (err) {
1399		free_percpu(dev->tstats);
1400		dev->tstats = NULL;
1401		return err;
1402	}
1403
1404	return 0;
1405}
1406
1407static void __net_init ipip6_fb_tunnel_init(struct net_device *dev)
1408{
1409	struct ip_tunnel *tunnel = netdev_priv(dev);
1410	struct iphdr *iph = &tunnel->parms.iph;
1411	struct net *net = dev_net(dev);
1412	struct sit_net *sitn = net_generic(net, sit_net_id);
1413
 
 
 
 
1414	iph->version		= 4;
1415	iph->protocol		= IPPROTO_IPV6;
1416	iph->ihl		= 5;
1417	iph->ttl		= 64;
1418
 
 
 
 
 
 
 
 
 
 
1419	dev_hold(dev);
1420	rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
 
1421}
1422
1423static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[],
1424			  struct netlink_ext_ack *extack)
1425{
1426	u8 proto;
1427
1428	if (!data || !data[IFLA_IPTUN_PROTO])
1429		return 0;
1430
1431	proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1432	if (!ipip6_valid_ip_proto(proto))
 
 
1433		return -EINVAL;
1434
1435	return 0;
1436}
1437
1438static void ipip6_netlink_parms(struct nlattr *data[],
1439				struct ip_tunnel_parm *parms,
1440				__u32 *fwmark)
1441{
1442	memset(parms, 0, sizeof(*parms));
1443
1444	parms->iph.version = 4;
1445	parms->iph.protocol = IPPROTO_IPV6;
1446	parms->iph.ihl = 5;
1447	parms->iph.ttl = 64;
1448
1449	if (!data)
1450		return;
1451
1452	if (data[IFLA_IPTUN_LINK])
1453		parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1454
1455	if (data[IFLA_IPTUN_LOCAL])
1456		parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
1457
1458	if (data[IFLA_IPTUN_REMOTE])
1459		parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
1460
1461	if (data[IFLA_IPTUN_TTL]) {
1462		parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
1463		if (parms->iph.ttl)
1464			parms->iph.frag_off = htons(IP_DF);
1465	}
1466
1467	if (data[IFLA_IPTUN_TOS])
1468		parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
1469
1470	if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
1471		parms->iph.frag_off = htons(IP_DF);
1472
1473	if (data[IFLA_IPTUN_FLAGS])
1474		parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
1475
1476	if (data[IFLA_IPTUN_PROTO])
1477		parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1478
1479	if (data[IFLA_IPTUN_FWMARK])
1480		*fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]);
1481}
1482
1483/* This function returns true when ENCAP attributes are present in the nl msg */
1484static bool ipip6_netlink_encap_parms(struct nlattr *data[],
1485				      struct ip_tunnel_encap *ipencap)
1486{
1487	bool ret = false;
1488
1489	memset(ipencap, 0, sizeof(*ipencap));
1490
1491	if (!data)
1492		return ret;
1493
1494	if (data[IFLA_IPTUN_ENCAP_TYPE]) {
1495		ret = true;
1496		ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
1497	}
1498
1499	if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
1500		ret = true;
1501		ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
1502	}
1503
1504	if (data[IFLA_IPTUN_ENCAP_SPORT]) {
1505		ret = true;
1506		ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
1507	}
1508
1509	if (data[IFLA_IPTUN_ENCAP_DPORT]) {
1510		ret = true;
1511		ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
1512	}
1513
1514	return ret;
1515}
1516
1517#ifdef CONFIG_IPV6_SIT_6RD
1518/* This function returns true when 6RD attributes are present in the nl msg */
1519static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
1520				    struct ip_tunnel_6rd *ip6rd)
1521{
1522	bool ret = false;
1523	memset(ip6rd, 0, sizeof(*ip6rd));
1524
1525	if (!data)
1526		return ret;
1527
1528	if (data[IFLA_IPTUN_6RD_PREFIX]) {
1529		ret = true;
1530		ip6rd->prefix = nla_get_in6_addr(data[IFLA_IPTUN_6RD_PREFIX]);
 
1531	}
1532
1533	if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
1534		ret = true;
1535		ip6rd->relay_prefix =
1536			nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
1537	}
1538
1539	if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
1540		ret = true;
1541		ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
1542	}
1543
1544	if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
1545		ret = true;
1546		ip6rd->relay_prefixlen =
1547			nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
1548	}
1549
1550	return ret;
1551}
1552#endif
1553
1554static int ipip6_newlink(struct net *src_net, struct net_device *dev,
1555			 struct nlattr *tb[], struct nlattr *data[],
1556			 struct netlink_ext_ack *extack)
1557{
1558	struct net *net = dev_net(dev);
1559	struct ip_tunnel *nt;
1560	struct ip_tunnel_encap ipencap;
1561#ifdef CONFIG_IPV6_SIT_6RD
1562	struct ip_tunnel_6rd ip6rd;
1563#endif
1564	int err;
1565
1566	nt = netdev_priv(dev);
1567
1568	if (ipip6_netlink_encap_parms(data, &ipencap)) {
1569		err = ip_tunnel_encap_setup(nt, &ipencap);
1570		if (err < 0)
1571			return err;
1572	}
1573
1574	ipip6_netlink_parms(data, &nt->parms, &nt->fwmark);
1575
1576	if (ipip6_tunnel_locate(net, &nt->parms, 0))
1577		return -EEXIST;
1578
1579	err = ipip6_tunnel_create(dev);
1580	if (err < 0)
1581		return err;
1582
1583	if (tb[IFLA_MTU]) {
1584		u32 mtu = nla_get_u32(tb[IFLA_MTU]);
1585
1586		if (mtu >= IPV6_MIN_MTU &&
1587		    mtu <= IP6_MAX_MTU - dev->hard_header_len)
1588			dev->mtu = mtu;
1589	}
1590
1591#ifdef CONFIG_IPV6_SIT_6RD
1592	if (ipip6_netlink_6rd_parms(data, &ip6rd))
1593		err = ipip6_tunnel_update_6rd(nt, &ip6rd);
1594#endif
1595
1596	return err;
1597}
1598
1599static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
1600			    struct nlattr *data[],
1601			    struct netlink_ext_ack *extack)
1602{
1603	struct ip_tunnel *t = netdev_priv(dev);
1604	struct ip_tunnel_parm p;
1605	struct ip_tunnel_encap ipencap;
1606	struct net *net = t->net;
1607	struct sit_net *sitn = net_generic(net, sit_net_id);
1608#ifdef CONFIG_IPV6_SIT_6RD
1609	struct ip_tunnel_6rd ip6rd;
1610#endif
1611	__u32 fwmark = t->fwmark;
1612	int err;
1613
1614	if (dev == sitn->fb_tunnel_dev)
1615		return -EINVAL;
1616
1617	if (ipip6_netlink_encap_parms(data, &ipencap)) {
1618		err = ip_tunnel_encap_setup(t, &ipencap);
1619		if (err < 0)
1620			return err;
1621	}
1622
1623	ipip6_netlink_parms(data, &p, &fwmark);
1624
1625	if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
1626	    (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
1627		return -EINVAL;
1628
1629	t = ipip6_tunnel_locate(net, &p, 0);
1630
1631	if (t) {
1632		if (t->dev != dev)
1633			return -EEXIST;
1634	} else
1635		t = netdev_priv(dev);
1636
1637	ipip6_tunnel_update(t, &p, fwmark);
1638
1639#ifdef CONFIG_IPV6_SIT_6RD
1640	if (ipip6_netlink_6rd_parms(data, &ip6rd))
1641		return ipip6_tunnel_update_6rd(t, &ip6rd);
1642#endif
1643
1644	return 0;
1645}
1646
1647static size_t ipip6_get_size(const struct net_device *dev)
1648{
1649	return
1650		/* IFLA_IPTUN_LINK */
1651		nla_total_size(4) +
1652		/* IFLA_IPTUN_LOCAL */
1653		nla_total_size(4) +
1654		/* IFLA_IPTUN_REMOTE */
1655		nla_total_size(4) +
1656		/* IFLA_IPTUN_TTL */
1657		nla_total_size(1) +
1658		/* IFLA_IPTUN_TOS */
1659		nla_total_size(1) +
1660		/* IFLA_IPTUN_PMTUDISC */
1661		nla_total_size(1) +
1662		/* IFLA_IPTUN_FLAGS */
1663		nla_total_size(2) +
1664		/* IFLA_IPTUN_PROTO */
1665		nla_total_size(1) +
1666#ifdef CONFIG_IPV6_SIT_6RD
1667		/* IFLA_IPTUN_6RD_PREFIX */
1668		nla_total_size(sizeof(struct in6_addr)) +
1669		/* IFLA_IPTUN_6RD_RELAY_PREFIX */
1670		nla_total_size(4) +
1671		/* IFLA_IPTUN_6RD_PREFIXLEN */
1672		nla_total_size(2) +
1673		/* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
1674		nla_total_size(2) +
1675#endif
1676		/* IFLA_IPTUN_ENCAP_TYPE */
1677		nla_total_size(2) +
1678		/* IFLA_IPTUN_ENCAP_FLAGS */
1679		nla_total_size(2) +
1680		/* IFLA_IPTUN_ENCAP_SPORT */
1681		nla_total_size(2) +
1682		/* IFLA_IPTUN_ENCAP_DPORT */
1683		nla_total_size(2) +
1684		/* IFLA_IPTUN_FWMARK */
1685		nla_total_size(4) +
1686		0;
1687}
1688
1689static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
1690{
1691	struct ip_tunnel *tunnel = netdev_priv(dev);
1692	struct ip_tunnel_parm *parm = &tunnel->parms;
1693
1694	if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1695	    nla_put_in_addr(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
1696	    nla_put_in_addr(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
1697	    nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
1698	    nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
1699	    nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
1700		       !!(parm->iph.frag_off & htons(IP_DF))) ||
1701	    nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
1702	    nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags) ||
1703	    nla_put_u32(skb, IFLA_IPTUN_FWMARK, tunnel->fwmark))
1704		goto nla_put_failure;
1705
1706#ifdef CONFIG_IPV6_SIT_6RD
1707	if (nla_put_in6_addr(skb, IFLA_IPTUN_6RD_PREFIX,
1708			     &tunnel->ip6rd.prefix) ||
1709	    nla_put_in_addr(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
1710			    tunnel->ip6rd.relay_prefix) ||
1711	    nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
1712			tunnel->ip6rd.prefixlen) ||
1713	    nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
1714			tunnel->ip6rd.relay_prefixlen))
1715		goto nla_put_failure;
1716#endif
1717
1718	if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
1719			tunnel->encap.type) ||
1720	    nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
1721			tunnel->encap.sport) ||
1722	    nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
1723			tunnel->encap.dport) ||
1724	    nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
1725			tunnel->encap.flags))
1726		goto nla_put_failure;
1727
1728	return 0;
1729
1730nla_put_failure:
1731	return -EMSGSIZE;
1732}
1733
1734static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
1735	[IFLA_IPTUN_LINK]		= { .type = NLA_U32 },
1736	[IFLA_IPTUN_LOCAL]		= { .type = NLA_U32 },
1737	[IFLA_IPTUN_REMOTE]		= { .type = NLA_U32 },
1738	[IFLA_IPTUN_TTL]		= { .type = NLA_U8 },
1739	[IFLA_IPTUN_TOS]		= { .type = NLA_U8 },
1740	[IFLA_IPTUN_PMTUDISC]		= { .type = NLA_U8 },
1741	[IFLA_IPTUN_FLAGS]		= { .type = NLA_U16 },
1742	[IFLA_IPTUN_PROTO]		= { .type = NLA_U8 },
1743#ifdef CONFIG_IPV6_SIT_6RD
1744	[IFLA_IPTUN_6RD_PREFIX]		= { .len = sizeof(struct in6_addr) },
1745	[IFLA_IPTUN_6RD_RELAY_PREFIX]	= { .type = NLA_U32 },
1746	[IFLA_IPTUN_6RD_PREFIXLEN]	= { .type = NLA_U16 },
1747	[IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
1748#endif
1749	[IFLA_IPTUN_ENCAP_TYPE]		= { .type = NLA_U16 },
1750	[IFLA_IPTUN_ENCAP_FLAGS]	= { .type = NLA_U16 },
1751	[IFLA_IPTUN_ENCAP_SPORT]	= { .type = NLA_U16 },
1752	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
1753	[IFLA_IPTUN_FWMARK]		= { .type = NLA_U32 },
1754};
1755
1756static void ipip6_dellink(struct net_device *dev, struct list_head *head)
1757{
1758	struct net *net = dev_net(dev);
1759	struct sit_net *sitn = net_generic(net, sit_net_id);
1760
1761	if (dev != sitn->fb_tunnel_dev)
1762		unregister_netdevice_queue(dev, head);
1763}
1764
1765static struct rtnl_link_ops sit_link_ops __read_mostly = {
1766	.kind		= "sit",
1767	.maxtype	= IFLA_IPTUN_MAX,
1768	.policy		= ipip6_policy,
1769	.priv_size	= sizeof(struct ip_tunnel),
1770	.setup		= ipip6_tunnel_setup,
1771	.validate	= ipip6_validate,
1772	.newlink	= ipip6_newlink,
1773	.changelink	= ipip6_changelink,
1774	.get_size	= ipip6_get_size,
1775	.fill_info	= ipip6_fill_info,
1776	.dellink	= ipip6_dellink,
1777	.get_link_net	= ip_tunnel_get_link_net,
1778};
1779
1780static struct xfrm_tunnel sit_handler __read_mostly = {
1781	.handler	=	ipip6_rcv,
1782	.err_handler	=	ipip6_err,
1783	.priority	=	1,
1784};
1785
1786static struct xfrm_tunnel ipip_handler __read_mostly = {
1787	.handler	=	ipip_rcv,
1788	.err_handler	=	ipip6_err,
1789	.priority	=	2,
1790};
1791
1792#if IS_ENABLED(CONFIG_MPLS)
1793static struct xfrm_tunnel mplsip_handler __read_mostly = {
1794	.handler	=	mplsip_rcv,
1795	.err_handler	=	ipip6_err,
1796	.priority	=	2,
1797};
1798#endif
1799
1800static void __net_exit sit_destroy_tunnels(struct net *net,
1801					   struct list_head *head)
1802{
1803	struct sit_net *sitn = net_generic(net, sit_net_id);
1804	struct net_device *dev, *aux;
1805	int prio;
1806
1807	for_each_netdev_safe(net, dev, aux)
1808		if (dev->rtnl_link_ops == &sit_link_ops)
1809			unregister_netdevice_queue(dev, head);
1810
1811	for (prio = 1; prio < 4; prio++) {
1812		int h;
1813		for (h = 0; h < IP6_SIT_HASH_SIZE; h++) {
1814			struct ip_tunnel *t;
1815
1816			t = rtnl_dereference(sitn->tunnels[prio][h]);
1817			while (t) {
1818				/* If dev is in the same netns, it has already
1819				 * been added to the list by the previous loop.
1820				 */
1821				if (!net_eq(dev_net(t->dev), net))
1822					unregister_netdevice_queue(t->dev,
1823								   head);
1824				t = rtnl_dereference(t->next);
1825			}
1826		}
1827	}
1828}
1829
1830static int __net_init sit_init_net(struct net *net)
1831{
1832	struct sit_net *sitn = net_generic(net, sit_net_id);
1833	struct ip_tunnel *t;
1834	int err;
1835
1836	sitn->tunnels[0] = sitn->tunnels_wc;
1837	sitn->tunnels[1] = sitn->tunnels_l;
1838	sitn->tunnels[2] = sitn->tunnels_r;
1839	sitn->tunnels[3] = sitn->tunnels_r_l;
1840
1841	if (!net_has_fallback_tunnels(net))
1842		return 0;
1843
1844	sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
1845					   NET_NAME_UNKNOWN,
1846					   ipip6_tunnel_setup);
1847	if (!sitn->fb_tunnel_dev) {
1848		err = -ENOMEM;
1849		goto err_alloc_dev;
1850	}
1851	dev_net_set(sitn->fb_tunnel_dev, net);
1852	sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
1853	/* FB netdevice is special: we have one, and only one per netns.
1854	 * Allowing to move it to another netns is clearly unsafe.
1855	 */
1856	sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1857
1858	err = register_netdev(sitn->fb_tunnel_dev);
1859	if (err)
1860		goto err_reg_dev;
1861
1862	ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1863	ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
 
 
1864
1865	t = netdev_priv(sitn->fb_tunnel_dev);
1866
1867	strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
1868	return 0;
1869
1870err_reg_dev:
 
 
1871	ipip6_dev_free(sitn->fb_tunnel_dev);
1872err_alloc_dev:
1873	return err;
1874}
1875
1876static void __net_exit sit_exit_batch_net(struct list_head *net_list)
1877{
1878	LIST_HEAD(list);
1879	struct net *net;
1880
1881	rtnl_lock();
1882	list_for_each_entry(net, net_list, exit_list)
1883		sit_destroy_tunnels(net, &list);
1884
1885	unregister_netdevice_many(&list);
1886	rtnl_unlock();
1887}
1888
1889static struct pernet_operations sit_net_ops = {
1890	.init = sit_init_net,
1891	.exit_batch = sit_exit_batch_net,
1892	.id   = &sit_net_id,
1893	.size = sizeof(struct sit_net),
1894};
1895
1896static void __exit sit_cleanup(void)
1897{
1898	rtnl_link_unregister(&sit_link_ops);
1899	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1900	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1901#if IS_ENABLED(CONFIG_MPLS)
1902	xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS);
1903#endif
1904
1905	unregister_pernet_device(&sit_net_ops);
1906	rcu_barrier(); /* Wait for completion of call_rcu()'s */
1907}
1908
1909static int __init sit_init(void)
1910{
1911	int err;
1912
1913	pr_info("IPv6, IPv4 and MPLS over IPv4 tunneling driver\n");
1914
1915	err = register_pernet_device(&sit_net_ops);
1916	if (err < 0)
1917		return err;
1918	err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
1919	if (err < 0) {
1920		pr_info("%s: can't register ip6ip4\n", __func__);
1921		goto xfrm_tunnel_failed;
1922	}
1923	err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1924	if (err < 0) {
1925		pr_info("%s: can't register ip4ip4\n", __func__);
1926		goto xfrm_tunnel4_failed;
1927	}
1928#if IS_ENABLED(CONFIG_MPLS)
1929	err = xfrm4_tunnel_register(&mplsip_handler, AF_MPLS);
1930	if (err < 0) {
1931		pr_info("%s: can't register mplsip\n", __func__);
1932		goto xfrm_tunnel_mpls_failed;
1933	}
1934#endif
1935	err = rtnl_link_register(&sit_link_ops);
1936	if (err < 0)
1937		goto rtnl_link_failed;
1938
1939out:
1940	return err;
1941
1942rtnl_link_failed:
1943#if IS_ENABLED(CONFIG_MPLS)
1944	xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS);
1945xfrm_tunnel_mpls_failed:
1946#endif
1947	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1948xfrm_tunnel4_failed:
1949	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1950xfrm_tunnel_failed:
1951	unregister_pernet_device(&sit_net_ops);
1952	goto out;
1953}
1954
1955module_init(sit_init);
1956module_exit(sit_cleanup);
1957MODULE_LICENSE("GPL");
1958MODULE_ALIAS_RTNL_LINK("sit");
1959MODULE_ALIAS_NETDEV("sit0");