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