Branch data Line data Source code
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 : :
68 : : static bool log_ecn_error = true;
69 : : module_param(log_ecn_error, bool, 0644);
70 : : MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
71 : :
72 : : static int ipip6_tunnel_init(struct net_device *dev);
73 : : static void ipip6_tunnel_setup(struct net_device *dev);
74 : : static void ipip6_dev_free(struct net_device *dev);
75 : : static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
76 : : __be32 *v4dst);
77 : : static struct rtnl_link_ops sit_link_ops __read_mostly;
78 : :
79 : : static int sit_net_id __read_mostly;
80 : : struct 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 : : */
93 : 0 : static struct ip_tunnel *ipip6_tunnel_lookup(struct net *net,
94 : : struct net_device *dev, __be32 remote, __be32 local)
95 : : {
96 : 0 : unsigned int h0 = HASH(remote);
97 : 0 : unsigned int h1 = HASH(local);
98 : : struct ip_tunnel *t;
99 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
100 : :
101 [ # # ]: 0 : for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) {
102 [ # # ][ # # ]: 0 : if (local == t->parms.iph.saddr &&
103 [ # # ]: 0 : remote == t->parms.iph.daddr &&
104 [ # # ][ # # ]: 0 : (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
[ # # ]
105 : 0 : (t->dev->flags & IFF_UP))
106 : : 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 || dev->iflink == t->parms.link) &&
[ # # ]
111 : 0 : (t->dev->flags & IFF_UP))
112 : : return t;
113 : : }
114 [ # # ]: 0 : for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) {
115 [ # # ][ # # ]: 0 : if (local == t->parms.iph.saddr &&
116 [ # # ][ # # ]: 0 : (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
[ # # ]
117 : 0 : (t->dev->flags & IFF_UP))
118 : : return t;
119 : : }
120 : 0 : t = rcu_dereference(sitn->tunnels_wc[0]);
121 [ # # ][ # # ]: 0 : if ((t != NULL) && (t->dev->flags & IFF_UP))
122 : 0 : return t;
123 : : return NULL;
124 : : }
125 : :
126 : 0 : static struct ip_tunnel __rcu **__ipip6_bucket(struct sit_net *sitn,
127 : : struct ip_tunnel_parm *parms)
128 : : {
129 : 0 : __be32 remote = parms->iph.daddr;
130 : 0 : __be32 local = parms->iph.saddr;
131 : : unsigned int h = 0;
132 : : int prio = 0;
133 : :
134 [ # # ][ # # ]: 0 : if (remote) {
135 : : prio |= 2;
136 : 0 : h ^= HASH(remote);
137 : : }
138 [ # # ][ # # ]: 0 : if (local) {
139 : 0 : prio |= 1;
140 : 0 : h ^= HASH(local);
141 : : }
142 : 0 : return &sitn->tunnels[prio][h];
143 : : }
144 : :
145 : : static inline struct ip_tunnel __rcu **ipip6_bucket(struct sit_net *sitn,
146 : : struct ip_tunnel *t)
147 : : {
148 : 0 : return __ipip6_bucket(sitn, &t->parms);
149 : : }
150 : :
151 : 0 : static 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 [ # # ]: 0 : for (tp = ipip6_bucket(sitn, t);
157 : 0 : (iter = rtnl_dereference(*tp)) != NULL;
158 : 0 : tp = &iter->next) {
159 [ # # ]: 0 : if (t == iter) {
160 : 0 : rcu_assign_pointer(*tp, t->next);
161 : 0 : break;
162 : : }
163 : : }
164 : 0 : }
165 : :
166 : 0 : static 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 : 0 : rcu_assign_pointer(t->next, rtnl_dereference(*tp));
171 : 0 : rcu_assign_pointer(*tp, t);
172 : 0 : }
173 : :
174 : : static 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 : :
191 : 0 : static int ipip6_tunnel_create(struct net_device *dev)
192 : : {
193 : 0 : struct ip_tunnel *t = netdev_priv(dev);
194 : : struct net *net = dev_net(dev);
195 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
196 : : int err;
197 : :
198 : 0 : err = ipip6_tunnel_init(dev);
199 [ # # ]: 0 : if (err < 0)
200 : : goto out;
201 : : ipip6_tunnel_clone_6rd(dev, sitn);
202 : :
203 [ # # ]: 0 : if ((__force u16)t->parms.i_flags & SIT_ISATAP)
204 : 0 : dev->priv_flags |= IFF_ISATAP;
205 : :
206 : 0 : err = register_netdevice(dev);
207 [ # # ]: 0 : if (err < 0)
208 : : goto out;
209 : :
210 : 0 : strcpy(t->parms.name, dev->name);
211 : 0 : dev->rtnl_link_ops = &sit_link_ops;
212 : :
213 : : dev_hold(dev);
214 : :
215 : 0 : ipip6_tunnel_link(sitn, t);
216 : 0 : return 0;
217 : :
218 : : out:
219 : 0 : return err;
220 : : }
221 : :
222 : 0 : static struct ip_tunnel *ipip6_tunnel_locate(struct net *net,
223 : 0 : struct ip_tunnel_parm *parms, int create)
224 : : {
225 : 0 : __be32 remote = parms->iph.daddr;
226 : 0 : __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 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
232 : :
233 [ # # ]: 0 : for (tp = __ipip6_bucket(sitn, parms);
234 : 0 : (t = rtnl_dereference(*tp)) != NULL;
235 : 0 : tp = &t->next) {
236 [ # # ][ # # ]: 0 : if (local == t->parms.iph.saddr &&
237 [ # # ]: 0 : remote == t->parms.iph.daddr &&
238 : 0 : parms->link == t->parms.link) {
239 [ # # ]: 0 : if (create)
240 : : return NULL;
241 : : else
242 : 0 : return t;
243 : : }
244 : : }
245 [ # # ]: 0 : if (!create)
246 : : goto failed;
247 : :
248 [ # # ]: 0 : if (parms->name[0])
249 : 0 : strlcpy(name, parms->name, IFNAMSIZ);
250 : : else
251 : 0 : strcpy(name, "sit%d");
252 : :
253 : 0 : dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
254 [ # # ]: 0 : if (dev == NULL)
255 : : return NULL;
256 : :
257 : : dev_net_set(dev, net);
258 : :
259 : 0 : nt = netdev_priv(dev);
260 : :
261 : 0 : nt->parms = *parms;
262 [ # # ]: 0 : if (ipip6_tunnel_create(dev) < 0)
263 : : goto failed_free;
264 : :
265 : : return nt;
266 : :
267 : : failed_free:
268 : 0 : ipip6_dev_free(dev);
269 : : failed:
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 : :
278 : : static 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 [ # # ]: 0 : for_each_prl_rcu(t->prl)
284 [ # # ]: 0 : if (prl->addr == addr)
285 : : break;
286 : : return prl;
287 : :
288 : : }
289 : :
290 : 0 : static 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 [ # # ]: 0 : if (copy_from_user(&kprl, a, sizeof(kprl)))
299 : : return -EFAULT;
300 : 0 : cmax = kprl.datalen / sizeof(kprl);
301 [ # # ][ # # ]: 0 : 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 [ # # ]: 0 : kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
308 [ # # ]: 0 : kcalloc(cmax, sizeof(*kp), GFP_KERNEL) :
309 : : NULL;
310 : :
311 : : rcu_read_lock();
312 : :
313 : 0 : ca = t->prl_count < cmax ? t->prl_count : cmax;
314 : :
315 [ # # ]: 0 : 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 [ # # ]: 0 : if (!kp) {
323 : : ret = -ENOMEM;
324 : : goto out;
325 : : }
326 : : }
327 : :
328 : : c = 0;
329 [ # # ]: 0 : for_each_prl_rcu(t->prl) {
330 [ # # ]: 0 : if (c >= cmax)
331 : : break;
332 [ # # ][ # # ]: 0 : if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
333 : 0 : continue;
334 : 0 : kp[c].addr = prl->addr;
335 : 0 : kp[c].flags = prl->flags;
336 : 0 : c++;
337 [ # # ]: 0 : if (kprl.addr != htonl(INADDR_ANY))
338 : : break;
339 : : }
340 : : out:
341 : : rcu_read_unlock();
342 : :
343 : 0 : len = sizeof(*kp) * c;
344 : : ret = 0;
345 [ # # ][ # # ]: 0 : if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
[ # # ]
346 : : ret = -EFAULT;
347 : :
348 : 0 : kfree(kp);
349 : :
350 : : return ret;
351 : : }
352 : :
353 : : static int
354 : 0 : ipip6_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 [ # # ]: 0 : if (a->addr == htonl(INADDR_ANY))
360 : : return -EINVAL;
361 : :
362 [ # # ]: 0 : ASSERT_RTNL();
363 : :
364 [ # # ]: 0 : for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) {
365 [ # # ]: 0 : if (p->addr == a->addr) {
366 [ # # ]: 0 : if (chg) {
367 : 0 : p->flags = a->flags;
368 : : goto out;
369 : : }
370 : : err = -EEXIST;
371 : : goto out;
372 : : }
373 : : }
374 : :
375 [ # # ]: 0 : if (chg) {
376 : : err = -ENXIO;
377 : : goto out;
378 : : }
379 : :
380 : : p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
381 [ # # ]: 0 : if (!p) {
382 : : err = -ENOBUFS;
383 : : goto out;
384 : : }
385 : :
386 : 0 : p->next = t->prl;
387 : 0 : p->addr = a->addr;
388 : 0 : p->flags = a->flags;
389 : 0 : t->prl_count++;
390 : 0 : rcu_assign_pointer(t->prl, p);
391 : : out:
392 : : return err;
393 : : }
394 : :
395 : 0 : static void prl_list_destroy_rcu(struct rcu_head *head)
396 : : {
397 : : struct ip_tunnel_prl_entry *p, *n;
398 : :
399 : 0 : p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
400 : : do {
401 : 0 : n = rcu_dereference_protected(p->next, 1);
402 : 0 : kfree(p);
403 : : p = n;
404 [ # # ]: 0 : } while (p);
405 : 0 : }
406 : :
407 : : static int
408 : 0 : ipip6_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 [ # # ]: 0 : ASSERT_RTNL();
415 : :
416 [ # # ][ # # ]: 0 : if (a && a->addr != htonl(INADDR_ANY)) {
417 [ # # ]: 0 : for (p = &t->prl;
418 : 0 : (x = rtnl_dereference(*p)) != NULL;
419 : 0 : p = &x->next) {
420 [ # # ]: 0 : if (x->addr == a->addr) {
421 : 0 : *p = x->next;
422 : 0 : kfree_rcu(x, rcu_head);
423 : 0 : t->prl_count--;
424 : 0 : goto out;
425 : : }
426 : : }
427 : : err = -ENXIO;
428 : : } else {
429 : 0 : x = rtnl_dereference(t->prl);
430 [ # # ]: 0 : if (x) {
431 : 0 : t->prl_count = 0;
432 : 0 : call_rcu(&x->rcu_head, prl_list_destroy_rcu);
433 : 0 : t->prl = NULL;
434 : : }
435 : : }
436 : : out:
437 : 0 : return err;
438 : : }
439 : :
440 : : static int
441 : 0 : isatap_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 : 0 : p = __ipip6_tunnel_locate_prl(t, iph->saddr);
448 [ # # ]: 0 : if (p) {
449 [ # # ]: 0 : if (p->flags & PRL_DEFAULT)
450 : 0 : skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
451 : : else
452 : 0 : skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
453 : : } else {
454 : 0 : const struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;
455 : :
456 [ # # ][ # # ]: 0 : if (ipv6_addr_is_isatap(addr6) &&
457 [ # # ]: 0 : (addr6->s6_addr32[3] == iph->saddr) &&
458 : 0 : ipv6_chk_prefix(addr6, t->dev))
459 : 0 : skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
460 : : else
461 : : ok = 0;
462 : : }
463 : : rcu_read_unlock();
464 : 0 : return ok;
465 : : }
466 : :
467 : 0 : static void ipip6_tunnel_uninit(struct net_device *dev)
468 : : {
469 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
470 : 0 : struct sit_net *sitn = net_generic(tunnel->net, sit_net_id);
471 : :
472 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev) {
473 : 0 : RCU_INIT_POINTER(sitn->tunnels_wc[0], NULL);
474 : : } else {
475 : 0 : ipip6_tunnel_unlink(sitn, tunnel);
476 : 0 : ipip6_tunnel_del_prl(tunnel, NULL);
477 : : }
478 : 0 : ip_tunnel_dst_reset_all(tunnel);
479 : : dev_put(dev);
480 : 0 : }
481 : :
482 : : /* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
483 : : * if sufficient data bytes are available
484 : : */
485 : 0 : static int ipip6_err_gen_icmpv6_unreach(struct sk_buff *skb)
486 : : {
487 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
488 : : struct rt6_info *rt;
489 : : struct sk_buff *skb2;
490 : :
491 [ # # ]: 0 : if (!pskb_may_pull(skb, iph->ihl * 4 + sizeof(struct ipv6hdr) + 8))
492 : : return 1;
493 : :
494 : 0 : skb2 = skb_clone(skb, GFP_ATOMIC);
495 : :
496 [ # # ]: 0 : if (!skb2)
497 : : return 1;
498 : :
499 : : skb_dst_drop(skb2);
500 : 0 : skb_pull(skb2, iph->ihl * 4);
501 : : skb_reset_network_header(skb2);
502 : :
503 : 0 : rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0, 0);
504 : :
505 [ # # ][ # # ]: 0 : if (rt && rt->dst.dev)
506 : 0 : skb2->dev = rt->dst.dev;
507 : :
508 : 0 : icmpv6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
509 : :
510 [ # # ]: 0 : if (rt)
511 : : ip6_rt_put(rt);
512 : :
513 : 0 : kfree_skb(skb2);
514 : :
515 : 0 : return 0;
516 : : }
517 : :
518 : 0 : static int ipip6_err(struct sk_buff *skb, u32 info)
519 : : {
520 : 0 : const struct iphdr *iph = (const struct iphdr *)skb->data;
521 : 0 : const int type = icmp_hdr(skb)->type;
522 : 0 : const int code = icmp_hdr(skb)->code;
523 : : struct ip_tunnel *t;
524 : : int err;
525 : :
526 [ # # # # ]: 0 : switch (type) {
527 : : default:
528 : : case ICMP_PARAMETERPROB:
529 : : return 0;
530 : :
531 : : case ICMP_DEST_UNREACH:
532 [ # # ]: 0 : 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 [ # # ]: 0 : if (code != ICMP_EXC_TTL)
546 : : return 0;
547 : : break;
548 : : case ICMP_REDIRECT:
549 : : break;
550 : : }
551 : :
552 : : err = -ENOENT;
553 : :
554 : 0 : t = ipip6_tunnel_lookup(dev_net(skb->dev),
555 : : skb->dev,
556 : : iph->daddr,
557 : : iph->saddr);
558 [ # # ]: 0 : if (t == NULL)
559 : : goto out;
560 : :
561 [ # # ]: 0 : if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
562 : 0 : ipv4_update_pmtu(skb, dev_net(skb->dev), info,
563 : 0 : t->dev->ifindex, 0, IPPROTO_IPV6, 0);
564 : : err = 0;
565 : 0 : goto out;
566 : : }
567 [ # # ]: 0 : if (type == ICMP_REDIRECT) {
568 : 0 : ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
569 : : IPPROTO_IPV6, 0);
570 : : err = 0;
571 : 0 : goto out;
572 : : }
573 : :
574 [ # # ]: 0 : if (t->parms.iph.daddr == 0)
575 : : goto out;
576 : :
577 : : err = 0;
578 [ # # ]: 0 : if (!ipip6_err_gen_icmpv6_unreach(skb))
579 : : goto out;
580 : :
581 [ # # ][ # # ]: 0 : if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
582 : : goto out;
583 : :
584 [ # # ]: 0 : if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
585 : 0 : t->err_count++;
586 : : else
587 : 0 : t->err_count = 1;
588 : 0 : t->err_time = jiffies;
589 : : out:
590 : 0 : return err;
591 : : }
592 : :
593 : : static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
594 : : const struct in6_addr *v6addr)
595 : : {
596 : 0 : __be32 v4embed = 0;
597 [ # # ][ # # ]: 0 : 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 : : */
614 : : static 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 : 0 : return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
626 : : }
627 : :
628 : : /* Returns true if a packet is spoofed */
629 : 0 : static bool packet_is_spoofed(struct sk_buff *skb,
630 : : const struct iphdr *iph,
631 : 0 : struct ip_tunnel *tunnel)
632 : : {
633 : : const struct ipv6hdr *ipv6h;
634 : :
635 [ # # ]: 0 : if (tunnel->dev->priv_flags & IFF_ISATAP) {
636 [ # # ]: 0 : if (!isatap_chksrc(skb, iph, tunnel))
637 : : return true;
638 : :
639 : 0 : return false;
640 : : }
641 : :
642 [ # # ]: 0 : if (tunnel->dev->flags & IFF_POINTOPOINT)
643 : : return false;
644 : :
645 : : ipv6h = ipv6_hdr(skb);
646 : :
647 [ # # ]: 0 : if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
648 [ # # ]: 0 : 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 [ # # ]: 0 : if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
655 : : return false;
656 : :
657 [ # # ]: 0 : if (only_dnatted(tunnel, &ipv6h->daddr))
658 : : return false;
659 : :
660 [ # # ]: 0 : 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 : :
666 : 0 : static 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 : 0 : tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
673 : : iph->saddr, iph->daddr);
674 [ # # ]: 0 : if (tunnel != NULL) {
675 : : struct pcpu_sw_netstats *tstats;
676 : :
677 [ # # ]: 0 : if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
678 : : tunnel->parms.iph.protocol != 0)
679 : : goto out;
680 : :
681 : 0 : skb->mac_header = skb->network_header;
682 : : skb_reset_network_header(skb);
683 : 0 : IPCB(skb)->flags = 0;
684 : 0 : skb->protocol = htons(ETH_P_IPV6);
685 : :
686 [ # # ]: 0 : if (packet_is_spoofed(skb, iph, tunnel)) {
687 : 0 : tunnel->dev->stats.rx_errors++;
688 : 0 : goto out;
689 : : }
690 : :
691 : 0 : __skb_tunnel_rx(skb, tunnel->dev, tunnel->net);
692 : :
693 : : err = IP_ECN_decapsulate(iph, skb);
694 [ # # ]: 0 : if (unlikely(err)) {
695 [ # # ]: 0 : if (log_ecn_error)
696 [ # # ]: 0 : net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
697 : : &iph->saddr, iph->tos);
698 [ # # ]: 0 : if (err > 1) {
699 : 0 : ++tunnel->dev->stats.rx_frame_errors;
700 : 0 : ++tunnel->dev->stats.rx_errors;
701 : 0 : goto out;
702 : : }
703 : : }
704 : :
705 : 0 : tstats = this_cpu_ptr(tunnel->dev->tstats);
706 : : u64_stats_update_begin(&tstats->syncp);
707 : 0 : tstats->rx_packets++;
708 : 0 : tstats->rx_bytes += skb->len;
709 : : u64_stats_update_end(&tstats->syncp);
710 : :
711 : 0 : netif_rx(skb);
712 : :
713 : 0 : return 0;
714 : : }
715 : :
716 : : /* no tunnel matched, let upstream know, ipsec may handle it */
717 : : return 1;
718 : : out:
719 : 0 : kfree_skb(skb);
720 : 0 : return 0;
721 : : }
722 : :
723 : : static const struct tnl_ptk_info tpi = {
724 : : /* no tunnel info required for ipip. */
725 : : .proto = htons(ETH_P_IP),
726 : : };
727 : :
728 : 0 : static 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 : 0 : tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
735 : : iph->saddr, iph->daddr);
736 [ # # ]: 0 : if (tunnel != NULL) {
737 [ # # ]: 0 : if (tunnel->parms.iph.protocol != IPPROTO_IPIP &&
738 : : tunnel->parms.iph.protocol != 0)
739 : : goto drop;
740 : :
741 [ # # ]: 0 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
742 : : goto drop;
743 [ # # ]: 0 : if (iptunnel_pull_header(skb, 0, tpi.proto))
744 : : goto drop;
745 : 0 : return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
746 : : }
747 : :
748 : : return 1;
749 : :
750 : : drop:
751 : 0 : kfree_skb(skb);
752 : 0 : 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 : : */
759 : 0 : static 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 [ # # ]: 0 : if (v6dst->s6_addr16[0] == htons(0x2002)) {
785 : : /* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
786 : 0 : memcpy(v4dst, &v6dst->s6_addr16[1], 4);
787 : : return true;
788 : : }
789 : : #endif
790 : : return false;
791 : : }
792 : :
793 : : static inline __be32 try_6rd(struct ip_tunnel *tunnel,
794 : : const struct in6_addr *v6dst)
795 : : {
796 : 0 : __be32 dst = 0;
797 : 0 : check_6rd(tunnel, v6dst, &dst);
798 : 0 : 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 : :
806 : 0 : static 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 : 0 : u8 tos = tunnel->parms.iph.tos;
813 : 0 : __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 : 0 : __be32 dst = tiph->daddr;
818 : : struct flowi4 fl4;
819 : : int mtu;
820 : 0 : const struct in6_addr *addr6;
821 : : int addr_type;
822 : : u8 ttl;
823 : : int err;
824 : :
825 [ # # ]: 0 : if (skb->protocol != htons(ETH_P_IPV6))
826 : : goto tx_error;
827 : :
828 [ # # ]: 0 : if (tos == 1)
829 : : tos = ipv6_get_dsfield(iph6);
830 : :
831 : : /* ISATAP (RFC4214) - must come before 6to4 */
832 [ # # ]: 0 : if (dev->priv_flags & IFF_ISATAP) {
833 : : struct neighbour *neigh = NULL;
834 : : bool do_tx_error = false;
835 : :
836 [ # # ]: 0 : if (skb_dst(skb))
837 : 0 : neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
838 : :
839 [ # # ]: 0 : if (neigh == NULL) {
840 : 0 : net_dbg_ratelimited("nexthop == NULL\n");
841 : : goto tx_error;
842 : : }
843 : :
844 : 0 : addr6 = (const struct in6_addr *)&neigh->primary_key;
845 : : addr_type = ipv6_addr_type(addr6);
846 : :
847 [ # # ][ # # ]: 0 : if ((addr_type & IPV6_ADDR_UNICAST) &&
848 : : ipv6_addr_is_isatap(addr6))
849 : 0 : dst = addr6->s6_addr32[3];
850 : : else
851 : : do_tx_error = true;
852 : :
853 : : neigh_release(neigh);
854 [ # # ]: 0 : if (do_tx_error)
855 : : goto tx_error;
856 : : }
857 : :
858 [ # # ]: 0 : if (!dst)
859 : 0 : dst = try_6rd(tunnel, &iph6->daddr);
860 : :
861 [ # # ]: 0 : if (!dst) {
862 : : struct neighbour *neigh = NULL;
863 : : bool do_tx_error = false;
864 : :
865 [ # # ]: 0 : if (skb_dst(skb))
866 : 0 : neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
867 : :
868 [ # # ]: 0 : if (neigh == NULL) {
869 : 0 : net_dbg_ratelimited("nexthop == NULL\n");
870 : : goto tx_error;
871 : : }
872 : :
873 : 0 : addr6 = (const struct in6_addr *)&neigh->primary_key;
874 : : addr_type = ipv6_addr_type(addr6);
875 : :
876 [ # # ]: 0 : if (addr_type == IPV6_ADDR_ANY) {
877 : 0 : addr6 = &ipv6_hdr(skb)->daddr;
878 : : addr_type = ipv6_addr_type(addr6);
879 : : }
880 : :
881 [ # # ]: 0 : if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
882 : 0 : dst = addr6->s6_addr32[3];
883 : : else
884 : : do_tx_error = true;
885 : :
886 : : neigh_release(neigh);
887 [ # # ]: 0 : if (do_tx_error)
888 : : goto tx_error;
889 : : }
890 : :
891 : 0 : 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 [ # # ]: 0 : if (IS_ERR(rt)) {
897 : 0 : dev->stats.tx_carrier_errors++;
898 : 0 : goto tx_error_icmp;
899 : : }
900 [ # # ]: 0 : if (rt->rt_type != RTN_UNICAST) {
901 : : ip_rt_put(rt);
902 : 0 : dev->stats.tx_carrier_errors++;
903 : 0 : goto tx_error_icmp;
904 : : }
905 : 0 : tdev = rt->dst.dev;
906 : :
907 [ # # ]: 0 : if (tdev == dev) {
908 : : ip_rt_put(rt);
909 : 0 : dev->stats.collisions++;
910 : 0 : goto tx_error;
911 : : }
912 : :
913 [ # # ]: 0 : if (df) {
914 : 0 : mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
915 : :
916 [ # # ]: 0 : if (mtu < 68) {
917 : 0 : dev->stats.collisions++;
918 : : ip_rt_put(rt);
919 : : goto tx_error;
920 : : }
921 : :
922 [ # # ]: 0 : if (mtu < IPV6_MIN_MTU) {
923 : : mtu = IPV6_MIN_MTU;
924 : : df = 0;
925 : : }
926 : :
927 [ # # ][ # # ]: 0 : if (tunnel->parms.iph.daddr && skb_dst(skb))
928 : 0 : skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
929 : :
930 [ # # ][ # # ]: 0 : if (skb->len > mtu && !skb_is_gso(skb)) {
931 : 0 : icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
932 : : ip_rt_put(rt);
933 : : goto tx_error;
934 : : }
935 : : }
936 : :
937 [ # # ]: 0 : if (tunnel->err_count > 0) {
938 [ # # ]: 0 : if (time_before(jiffies,
939 : : tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
940 : 0 : tunnel->err_count--;
941 : : dst_link_failure(skb);
942 : : } else
943 : 0 : tunnel->err_count = 0;
944 : : }
945 : :
946 : : /*
947 : : * Okay, now see if we can stuff it in the buffer as-is.
948 : : */
949 : 0 : max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);
950 : :
951 [ # # ][ # # ]: 0 : if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
[ # # ]
952 [ # # ]: 0 : (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
953 : 0 : struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
954 [ # # ]: 0 : if (!new_skb) {
955 : : ip_rt_put(rt);
956 : 0 : dev->stats.tx_dropped++;
957 : 0 : kfree_skb(skb);
958 : 0 : return NETDEV_TX_OK;
959 : : }
960 [ # # ]: 0 : if (skb->sk)
961 : : skb_set_owner_w(new_skb, skb->sk);
962 : 0 : dev_kfree_skb(skb);
963 : : skb = new_skb;
964 : : iph6 = ipv6_hdr(skb);
965 : : }
966 : 0 : ttl = tiph->ttl;
967 [ # # ]: 0 : if (ttl == 0)
968 : 0 : ttl = iph6->hop_limit;
969 : : tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
970 : :
971 : 0 : skb = iptunnel_handle_offloads(skb, false, SKB_GSO_SIT);
972 [ # # ]: 0 : if (IS_ERR(skb)) {
973 : : ip_rt_put(rt);
974 : : goto out;
975 : : }
976 : :
977 : 0 : err = iptunnel_xmit(rt, skb, fl4.saddr, fl4.daddr, IPPROTO_IPV6, tos,
978 : : ttl, df, !net_eq(tunnel->net, dev_net(dev)));
979 : 0 : iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
980 : : return NETDEV_TX_OK;
981 : :
982 : : tx_error_icmp:
983 : : dst_link_failure(skb);
984 : : tx_error:
985 : 0 : kfree_skb(skb);
986 : : out:
987 : 0 : dev->stats.tx_errors++;
988 : 0 : return NETDEV_TX_OK;
989 : : }
990 : :
991 : 0 : static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
992 : : {
993 : : struct ip_tunnel *tunnel = netdev_priv(dev);
994 : 0 : const struct iphdr *tiph = &tunnel->parms.iph;
995 : :
996 : 0 : skb = iptunnel_handle_offloads(skb, false, SKB_GSO_IPIP);
997 [ # # ]: 0 : if (IS_ERR(skb))
998 : : goto out;
999 : :
1000 : 0 : ip_tunnel_xmit(skb, dev, tiph, IPPROTO_IPIP);
1001 : 0 : return NETDEV_TX_OK;
1002 : : out:
1003 : 0 : dev->stats.tx_errors++;
1004 : 0 : return NETDEV_TX_OK;
1005 : : }
1006 : :
1007 : 0 : static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
1008 : : struct net_device *dev)
1009 : : {
1010 [ # # # ]: 0 : switch (skb->protocol) {
1011 : : case htons(ETH_P_IP):
1012 : 0 : ipip_tunnel_xmit(skb, dev);
1013 : 0 : break;
1014 : : case htons(ETH_P_IPV6):
1015 : 0 : ipip6_tunnel_xmit(skb, dev);
1016 : 0 : break;
1017 : : default:
1018 : : goto tx_err;
1019 : : }
1020 : :
1021 : : return NETDEV_TX_OK;
1022 : :
1023 : : tx_err:
1024 : 0 : dev->stats.tx_errors++;
1025 : 0 : kfree_skb(skb);
1026 : 0 : return NETDEV_TX_OK;
1027 : :
1028 : : }
1029 : :
1030 : 0 : static void ipip6_tunnel_bind_dev(struct net_device *dev)
1031 : : {
1032 : : struct net_device *tdev = NULL;
1033 : : struct ip_tunnel *tunnel;
1034 : : const struct iphdr *iph;
1035 : : struct flowi4 fl4;
1036 : :
1037 : : tunnel = netdev_priv(dev);
1038 : : iph = &tunnel->parms.iph;
1039 : :
1040 [ # # ]: 0 : if (iph->daddr) {
1041 : 0 : struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
1042 : : NULL,
1043 : : iph->daddr, iph->saddr,
1044 : : 0, 0,
1045 : : IPPROTO_IPV6,
1046 : 0 : RT_TOS(iph->tos),
1047 : : tunnel->parms.link);
1048 : :
1049 [ # # ]: 0 : if (!IS_ERR(rt)) {
1050 : 0 : tdev = rt->dst.dev;
1051 : : ip_rt_put(rt);
1052 : : }
1053 : 0 : dev->flags |= IFF_POINTOPOINT;
1054 : : }
1055 : :
1056 [ # # ][ # # ]: 0 : if (!tdev && tunnel->parms.link)
1057 : 0 : tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
1058 : :
1059 [ # # ]: 0 : if (tdev) {
1060 : 0 : dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
1061 : 0 : dev->mtu = tdev->mtu - sizeof(struct iphdr);
1062 [ # # ]: 0 : if (dev->mtu < IPV6_MIN_MTU)
1063 : 0 : dev->mtu = IPV6_MIN_MTU;
1064 : : }
1065 : 0 : dev->iflink = tunnel->parms.link;
1066 : 0 : }
1067 : :
1068 : 0 : static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
1069 : : {
1070 : 0 : struct net *net = t->net;
1071 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1072 : :
1073 : 0 : ipip6_tunnel_unlink(sitn, t);
1074 : 0 : synchronize_net();
1075 : 0 : t->parms.iph.saddr = p->iph.saddr;
1076 : 0 : t->parms.iph.daddr = p->iph.daddr;
1077 : 0 : memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
1078 : 0 : memcpy(t->dev->broadcast, &p->iph.daddr, 4);
1079 : 0 : ipip6_tunnel_link(sitn, t);
1080 : 0 : t->parms.iph.ttl = p->iph.ttl;
1081 : 0 : t->parms.iph.tos = p->iph.tos;
1082 [ # # ]: 0 : if (t->parms.link != p->link) {
1083 : 0 : t->parms.link = p->link;
1084 : 0 : ipip6_tunnel_bind_dev(t->dev);
1085 : : }
1086 : 0 : ip_tunnel_dst_reset_all(t);
1087 : 0 : netdev_state_change(t->dev);
1088 : 0 : }
1089 : :
1090 : : #ifdef CONFIG_IPV6_SIT_6RD
1091 : : static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
1092 : : struct ip_tunnel_6rd *ip6rd)
1093 : : {
1094 : : struct in6_addr prefix;
1095 : : __be32 relay_prefix;
1096 : :
1097 : : if (ip6rd->relay_prefixlen > 32 ||
1098 : : ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
1099 : : return -EINVAL;
1100 : :
1101 : : ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
1102 : : if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
1103 : : return -EINVAL;
1104 : : if (ip6rd->relay_prefixlen)
1105 : : relay_prefix = ip6rd->relay_prefix &
1106 : : htonl(0xffffffffUL <<
1107 : : (32 - ip6rd->relay_prefixlen));
1108 : : else
1109 : : relay_prefix = 0;
1110 : : if (relay_prefix != ip6rd->relay_prefix)
1111 : : return -EINVAL;
1112 : :
1113 : : t->ip6rd.prefix = prefix;
1114 : : t->ip6rd.relay_prefix = relay_prefix;
1115 : : t->ip6rd.prefixlen = ip6rd->prefixlen;
1116 : : t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
1117 : : ip_tunnel_dst_reset_all(t);
1118 : : netdev_state_change(t->dev);
1119 : : return 0;
1120 : : }
1121 : : #endif
1122 : :
1123 : : static int
1124 : 0 : ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
1125 : : {
1126 : : int err = 0;
1127 : : struct ip_tunnel_parm p;
1128 : : struct ip_tunnel_prl prl;
1129 : : struct ip_tunnel *t;
1130 : : struct net *net = dev_net(dev);
1131 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1132 : : #ifdef CONFIG_IPV6_SIT_6RD
1133 : : struct ip_tunnel_6rd ip6rd;
1134 : : #endif
1135 : :
1136 [ # # # # : 0 : switch (cmd) {
# # ]
1137 : : case SIOCGETTUNNEL:
1138 : : #ifdef CONFIG_IPV6_SIT_6RD
1139 : : case SIOCGET6RD:
1140 : : #endif
1141 : : t = NULL;
1142 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev) {
1143 [ # # ]: 0 : if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1144 : : err = -EFAULT;
1145 : : break;
1146 : : }
1147 : 0 : t = ipip6_tunnel_locate(net, &p, 0);
1148 : : }
1149 [ # # ]: 0 : if (t == NULL)
1150 : 0 : t = netdev_priv(dev);
1151 : :
1152 : : err = -EFAULT;
1153 [ # # ]: 0 : if (cmd == SIOCGETTUNNEL) {
1154 : 0 : memcpy(&p, &t->parms, sizeof(p));
1155 [ # # ]: 0 : 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 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1176 : : goto done;
1177 : :
1178 : : err = -EFAULT;
1179 [ # # ]: 0 : if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1180 : : goto done;
1181 : :
1182 : : err = -EINVAL;
1183 [ # # ]: 0 : if (p.iph.protocol != IPPROTO_IPV6 &&
1184 [ # # ]: 0 : p.iph.protocol != IPPROTO_IPIP &&
1185 : : p.iph.protocol != 0)
1186 : : goto done;
1187 [ # # ]: 0 : if (p.iph.version != 4 ||
1188 [ # # ]: 0 : p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
1189 : : goto done;
1190 [ # # ]: 0 : if (p.iph.ttl)
1191 : 0 : p.iph.frag_off |= htons(IP_DF);
1192 : :
1193 : 0 : t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1194 : :
1195 [ # # ][ # # ]: 0 : if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1196 [ # # ]: 0 : if (t != NULL) {
1197 [ # # ]: 0 : if (t->dev != dev) {
1198 : : err = -EEXIST;
1199 : : break;
1200 : : }
1201 : : } else {
1202 [ # # ][ # # ]: 0 : if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
[ # # ]
1203 [ # # ]: 0 : (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
1204 : : err = -EINVAL;
1205 : : break;
1206 : : }
1207 : 0 : t = netdev_priv(dev);
1208 : : }
1209 : :
1210 : 0 : ipip6_tunnel_update(t, &p);
1211 : : }
1212 : :
1213 [ # # ]: 0 : if (t) {
1214 : : err = 0;
1215 [ # # ]: 0 : if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1216 : : err = -EFAULT;
1217 : : } else
1218 [ # # ]: 0 : err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1219 : : break;
1220 : :
1221 : : case SIOCDELTUNNEL:
1222 : : err = -EPERM;
1223 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1224 : : goto done;
1225 : :
1226 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev) {
1227 : : err = -EFAULT;
1228 [ # # ]: 0 : if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1229 : : goto done;
1230 : : err = -ENOENT;
1231 [ # # ]: 0 : if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL)
1232 : : goto done;
1233 : : err = -EPERM;
1234 [ # # ]: 0 : if (t == netdev_priv(sitn->fb_tunnel_dev))
1235 : : goto done;
1236 : 0 : dev = t->dev;
1237 : : }
1238 : : unregister_netdevice(dev);
1239 : : err = 0;
1240 : 0 : break;
1241 : :
1242 : : case SIOCGETPRL:
1243 : : err = -EINVAL;
1244 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev)
1245 : : goto done;
1246 : : err = -ENOENT;
1247 [ # # ]: 0 : if (!(t = netdev_priv(dev)))
1248 : : goto done;
1249 : 0 : err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
1250 : 0 : break;
1251 : :
1252 : : case SIOCADDPRL:
1253 : : case SIOCDELPRL:
1254 : : case SIOCCHGPRL:
1255 : : err = -EPERM;
1256 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1257 : : goto done;
1258 : : err = -EINVAL;
1259 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev)
1260 : : goto done;
1261 : : err = -EFAULT;
1262 [ # # ]: 0 : if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
1263 : : goto done;
1264 : : err = -ENOENT;
1265 [ # # ]: 0 : if (!(t = netdev_priv(dev)))
1266 : : goto done;
1267 : :
1268 [ # # # ]: 0 : switch (cmd) {
1269 : : case SIOCDELPRL:
1270 : 0 : err = ipip6_tunnel_del_prl(t, &prl);
1271 : 0 : break;
1272 : : case SIOCADDPRL:
1273 : : case SIOCCHGPRL:
1274 : 0 : err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
1275 : 0 : break;
1276 : : }
1277 : 0 : ip_tunnel_dst_reset_all(t);
1278 : 0 : netdev_state_change(dev);
1279 : 0 : break;
1280 : :
1281 : : #ifdef CONFIG_IPV6_SIT_6RD
1282 : : case SIOCADD6RD:
1283 : : case SIOCCHG6RD:
1284 : : case SIOCDEL6RD:
1285 : : err = -EPERM;
1286 : : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1287 : : goto done;
1288 : :
1289 : : err = -EFAULT;
1290 : : if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
1291 : : sizeof(ip6rd)))
1292 : : goto done;
1293 : :
1294 : : t = netdev_priv(dev);
1295 : :
1296 : : if (cmd != SIOCDEL6RD) {
1297 : : err = ipip6_tunnel_update_6rd(t, &ip6rd);
1298 : : if (err < 0)
1299 : : goto done;
1300 : : } else
1301 : : ipip6_tunnel_clone_6rd(dev, sitn);
1302 : :
1303 : : err = 0;
1304 : : break;
1305 : : #endif
1306 : :
1307 : : default:
1308 : : err = -EINVAL;
1309 : : }
1310 : :
1311 : : done:
1312 : 0 : return err;
1313 : : }
1314 : :
1315 : 0 : static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1316 : : {
1317 [ # # ]: 0 : if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
1318 : : return -EINVAL;
1319 : 0 : dev->mtu = new_mtu;
1320 : 0 : return 0;
1321 : : }
1322 : :
1323 : : static const struct net_device_ops ipip6_netdev_ops = {
1324 : : .ndo_uninit = ipip6_tunnel_uninit,
1325 : : .ndo_start_xmit = sit_tunnel_xmit,
1326 : : .ndo_do_ioctl = ipip6_tunnel_ioctl,
1327 : : .ndo_change_mtu = ipip6_tunnel_change_mtu,
1328 : : .ndo_get_stats64 = ip_tunnel_get_stats64,
1329 : : };
1330 : :
1331 : 0 : static void ipip6_dev_free(struct net_device *dev)
1332 : : {
1333 : : struct ip_tunnel *tunnel = netdev_priv(dev);
1334 : :
1335 : 0 : free_percpu(tunnel->dst_cache);
1336 : 0 : free_percpu(dev->tstats);
1337 : 0 : free_netdev(dev);
1338 : 0 : }
1339 : :
1340 : : #define SIT_FEATURES (NETIF_F_SG | \
1341 : : NETIF_F_FRAGLIST | \
1342 : : NETIF_F_HIGHDMA | \
1343 : : NETIF_F_GSO_SOFTWARE | \
1344 : : NETIF_F_HW_CSUM)
1345 : :
1346 : 0 : static void ipip6_tunnel_setup(struct net_device *dev)
1347 : : {
1348 : 0 : dev->netdev_ops = &ipip6_netdev_ops;
1349 : 0 : dev->destructor = ipip6_dev_free;
1350 : :
1351 : 0 : dev->type = ARPHRD_SIT;
1352 : 0 : dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
1353 : 0 : dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
1354 : 0 : dev->flags = IFF_NOARP;
1355 : 0 : dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1356 : 0 : dev->iflink = 0;
1357 : 0 : dev->addr_len = 4;
1358 : 0 : dev->features |= NETIF_F_LLTX;
1359 : 0 : dev->features |= SIT_FEATURES;
1360 : 0 : dev->hw_features |= SIT_FEATURES;
1361 : 0 : }
1362 : :
1363 : 0 : static int ipip6_tunnel_init(struct net_device *dev)
1364 : : {
1365 : : struct ip_tunnel *tunnel = netdev_priv(dev);
1366 : : int i;
1367 : :
1368 : 0 : tunnel->dev = dev;
1369 : 0 : tunnel->net = dev_net(dev);
1370 : :
1371 : 0 : memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1372 : 0 : memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1373 : :
1374 : 0 : ipip6_tunnel_bind_dev(dev);
1375 : 0 : dev->tstats = alloc_percpu(struct pcpu_sw_netstats);
1376 [ # # ]: 0 : if (!dev->tstats)
1377 : : return -ENOMEM;
1378 : :
1379 [ # # ]: 0 : for_each_possible_cpu(i) {
1380 : : struct pcpu_sw_netstats *ipip6_tunnel_stats;
1381 : 0 : ipip6_tunnel_stats = per_cpu_ptr(dev->tstats, i);
1382 : : u64_stats_init(&ipip6_tunnel_stats->syncp);
1383 : : }
1384 : :
1385 : 0 : tunnel->dst_cache = alloc_percpu(struct ip_tunnel_dst);
1386 [ # # ]: 0 : if (!tunnel->dst_cache) {
1387 : 0 : free_percpu(dev->tstats);
1388 : 0 : return -ENOMEM;
1389 : : }
1390 : :
1391 : : return 0;
1392 : : }
1393 : :
1394 : 0 : static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
1395 : : {
1396 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
1397 : : struct iphdr *iph = &tunnel->parms.iph;
1398 : : struct net *net = dev_net(dev);
1399 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1400 : : int i;
1401 : :
1402 : 0 : tunnel->dev = dev;
1403 : 0 : tunnel->net = dev_net(dev);
1404 : 0 : strcpy(tunnel->parms.name, dev->name);
1405 : :
1406 : 0 : iph->version = 4;
1407 : 0 : iph->protocol = IPPROTO_IPV6;
1408 : 0 : iph->ihl = 5;
1409 : 0 : iph->ttl = 64;
1410 : :
1411 : 0 : dev->tstats = alloc_percpu(struct pcpu_sw_netstats);
1412 [ # # ]: 0 : if (!dev->tstats)
1413 : : return -ENOMEM;
1414 : :
1415 [ # # ]: 0 : for_each_possible_cpu(i) {
1416 : : struct pcpu_sw_netstats *ipip6_fb_stats;
1417 : 0 : ipip6_fb_stats = per_cpu_ptr(dev->tstats, i);
1418 : : u64_stats_init(&ipip6_fb_stats->syncp);
1419 : : }
1420 : :
1421 : 0 : tunnel->dst_cache = alloc_percpu(struct ip_tunnel_dst);
1422 [ # # ]: 0 : if (!tunnel->dst_cache) {
1423 : 0 : free_percpu(dev->tstats);
1424 : 0 : return -ENOMEM;
1425 : : }
1426 : :
1427 : : dev_hold(dev);
1428 : 0 : rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
1429 : 0 : return 0;
1430 : : }
1431 : :
1432 : 0 : static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[])
1433 : : {
1434 : : u8 proto;
1435 : :
1436 [ # # ][ # # ]: 0 : if (!data || !data[IFLA_IPTUN_PROTO])
1437 : : return 0;
1438 : :
1439 : : proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1440 [ # # ]: 0 : if (proto != IPPROTO_IPV6 &&
1441 [ # # ]: 0 : proto != IPPROTO_IPIP &&
1442 : : proto != 0)
1443 : : return -EINVAL;
1444 : :
1445 : 0 : return 0;
1446 : : }
1447 : :
1448 : 0 : static void ipip6_netlink_parms(struct nlattr *data[],
1449 : : struct ip_tunnel_parm *parms)
1450 : : {
1451 : 0 : memset(parms, 0, sizeof(*parms));
1452 : :
1453 : 0 : parms->iph.version = 4;
1454 : 0 : parms->iph.protocol = IPPROTO_IPV6;
1455 : 0 : parms->iph.ihl = 5;
1456 : 0 : parms->iph.ttl = 64;
1457 : :
1458 [ # # ]: 0 : if (!data)
1459 : 0 : return;
1460 : :
1461 [ # # ]: 0 : if (data[IFLA_IPTUN_LINK])
1462 : 0 : parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1463 : :
1464 [ # # ]: 0 : if (data[IFLA_IPTUN_LOCAL])
1465 : 0 : parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
1466 : :
1467 [ # # ]: 0 : if (data[IFLA_IPTUN_REMOTE])
1468 : 0 : parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
1469 : :
1470 [ # # ]: 0 : if (data[IFLA_IPTUN_TTL]) {
1471 : 0 : parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
1472 [ # # ]: 0 : if (parms->iph.ttl)
1473 : 0 : parms->iph.frag_off = htons(IP_DF);
1474 : : }
1475 : :
1476 [ # # ]: 0 : if (data[IFLA_IPTUN_TOS])
1477 : 0 : parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
1478 : :
1479 [ # # ][ # # ]: 0 : if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
1480 : 0 : parms->iph.frag_off = htons(IP_DF);
1481 : :
1482 [ # # ]: 0 : if (data[IFLA_IPTUN_FLAGS])
1483 : 0 : parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
1484 : :
1485 [ # # ]: 0 : if (data[IFLA_IPTUN_PROTO])
1486 : 0 : parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1487 : :
1488 : : }
1489 : :
1490 : : #ifdef CONFIG_IPV6_SIT_6RD
1491 : : /* This function returns true when 6RD attributes are present in the nl msg */
1492 : : static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
1493 : : struct ip_tunnel_6rd *ip6rd)
1494 : : {
1495 : : bool ret = false;
1496 : : memset(ip6rd, 0, sizeof(*ip6rd));
1497 : :
1498 : : if (!data)
1499 : : return ret;
1500 : :
1501 : : if (data[IFLA_IPTUN_6RD_PREFIX]) {
1502 : : ret = true;
1503 : : nla_memcpy(&ip6rd->prefix, data[IFLA_IPTUN_6RD_PREFIX],
1504 : : sizeof(struct in6_addr));
1505 : : }
1506 : :
1507 : : if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
1508 : : ret = true;
1509 : : ip6rd->relay_prefix =
1510 : : nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
1511 : : }
1512 : :
1513 : : if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
1514 : : ret = true;
1515 : : ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
1516 : : }
1517 : :
1518 : : if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
1519 : : ret = true;
1520 : : ip6rd->relay_prefixlen =
1521 : : nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
1522 : : }
1523 : :
1524 : : return ret;
1525 : : }
1526 : : #endif
1527 : :
1528 : 0 : static int ipip6_newlink(struct net *src_net, struct net_device *dev,
1529 : : struct nlattr *tb[], struct nlattr *data[])
1530 : : {
1531 : : struct net *net = dev_net(dev);
1532 : : struct ip_tunnel *nt;
1533 : : #ifdef CONFIG_IPV6_SIT_6RD
1534 : : struct ip_tunnel_6rd ip6rd;
1535 : : #endif
1536 : : int err;
1537 : :
1538 : : nt = netdev_priv(dev);
1539 : 0 : ipip6_netlink_parms(data, &nt->parms);
1540 : :
1541 [ # # ]: 0 : if (ipip6_tunnel_locate(net, &nt->parms, 0))
1542 : : return -EEXIST;
1543 : :
1544 : 0 : err = ipip6_tunnel_create(dev);
1545 : : if (err < 0)
1546 : : return err;
1547 : :
1548 : : #ifdef CONFIG_IPV6_SIT_6RD
1549 : : if (ipip6_netlink_6rd_parms(data, &ip6rd))
1550 : : err = ipip6_tunnel_update_6rd(nt, &ip6rd);
1551 : : #endif
1552 : :
1553 : : return err;
1554 : : }
1555 : :
1556 : 0 : static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
1557 : : struct nlattr *data[])
1558 : : {
1559 : : struct ip_tunnel *t = netdev_priv(dev);
1560 : : struct ip_tunnel_parm p;
1561 : 0 : struct net *net = t->net;
1562 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1563 : : #ifdef CONFIG_IPV6_SIT_6RD
1564 : : struct ip_tunnel_6rd ip6rd;
1565 : : #endif
1566 : :
1567 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev)
1568 : : return -EINVAL;
1569 : :
1570 : 0 : ipip6_netlink_parms(data, &p);
1571 : :
1572 [ # # ][ # # ]: 0 : if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
[ # # ]
1573 [ # # ]: 0 : (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
1574 : : return -EINVAL;
1575 : :
1576 : 0 : t = ipip6_tunnel_locate(net, &p, 0);
1577 : :
1578 [ # # ]: 0 : if (t) {
1579 [ # # ]: 0 : if (t->dev != dev)
1580 : : return -EEXIST;
1581 : : } else
1582 : 0 : t = netdev_priv(dev);
1583 : :
1584 : 0 : ipip6_tunnel_update(t, &p);
1585 : :
1586 : : #ifdef CONFIG_IPV6_SIT_6RD
1587 : : if (ipip6_netlink_6rd_parms(data, &ip6rd))
1588 : : return ipip6_tunnel_update_6rd(t, &ip6rd);
1589 : : #endif
1590 : :
1591 : 0 : return 0;
1592 : : }
1593 : :
1594 : 0 : static size_t ipip6_get_size(const struct net_device *dev)
1595 : : {
1596 : 0 : return
1597 : : /* IFLA_IPTUN_LINK */
1598 : : nla_total_size(4) +
1599 : : /* IFLA_IPTUN_LOCAL */
1600 : : nla_total_size(4) +
1601 : : /* IFLA_IPTUN_REMOTE */
1602 : : nla_total_size(4) +
1603 : : /* IFLA_IPTUN_TTL */
1604 : : nla_total_size(1) +
1605 : : /* IFLA_IPTUN_TOS */
1606 : : nla_total_size(1) +
1607 : : /* IFLA_IPTUN_PMTUDISC */
1608 : : nla_total_size(1) +
1609 : : /* IFLA_IPTUN_FLAGS */
1610 : : nla_total_size(2) +
1611 : : /* IFLA_IPTUN_PROTO */
1612 : : nla_total_size(1) +
1613 : : #ifdef CONFIG_IPV6_SIT_6RD
1614 : : /* IFLA_IPTUN_6RD_PREFIX */
1615 : : nla_total_size(sizeof(struct in6_addr)) +
1616 : : /* IFLA_IPTUN_6RD_RELAY_PREFIX */
1617 : : nla_total_size(4) +
1618 : : /* IFLA_IPTUN_6RD_PREFIXLEN */
1619 : : nla_total_size(2) +
1620 : : /* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
1621 : : nla_total_size(2) +
1622 : : #endif
1623 : : 0;
1624 : : }
1625 : :
1626 : 0 : static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
1627 : : {
1628 : : struct ip_tunnel *tunnel = netdev_priv(dev);
1629 : : struct ip_tunnel_parm *parm = &tunnel->parms;
1630 : :
1631 [ + - + - ]: 1110 : if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1632 [ + - ]: 555 : nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
1633 [ + - ]: 555 : nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
1634 [ + - ]: 555 : nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
1635 [ + - ]: 555 : nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
1636 : 555 : nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
1637 [ + - ]: 555 : !!(parm->iph.frag_off & htons(IP_DF))) ||
1638 [ - + ]: 555 : nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
1639 : 555 : nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags))
1640 : : goto nla_put_failure;
1641 : :
1642 : : #ifdef CONFIG_IPV6_SIT_6RD
1643 : : if (nla_put(skb, IFLA_IPTUN_6RD_PREFIX, sizeof(struct in6_addr),
1644 : : &tunnel->ip6rd.prefix) ||
1645 : : nla_put_be32(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
1646 : : tunnel->ip6rd.relay_prefix) ||
1647 : : nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
1648 : : tunnel->ip6rd.prefixlen) ||
1649 : : nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
1650 : : tunnel->ip6rd.relay_prefixlen))
1651 : : goto nla_put_failure;
1652 : : #endif
1653 : :
1654 : : return 0;
1655 : :
1656 : : nla_put_failure:
1657 : : return -EMSGSIZE;
1658 : : }
1659 : :
1660 : : static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
1661 : : [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
1662 : : [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
1663 : : [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
1664 : : [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
1665 : : [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
1666 : : [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
1667 : : [IFLA_IPTUN_FLAGS] = { .type = NLA_U16 },
1668 : : [IFLA_IPTUN_PROTO] = { .type = NLA_U8 },
1669 : : #ifdef CONFIG_IPV6_SIT_6RD
1670 : : [IFLA_IPTUN_6RD_PREFIX] = { .len = sizeof(struct in6_addr) },
1671 : : [IFLA_IPTUN_6RD_RELAY_PREFIX] = { .type = NLA_U32 },
1672 : : [IFLA_IPTUN_6RD_PREFIXLEN] = { .type = NLA_U16 },
1673 : : [IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
1674 : : #endif
1675 : : };
1676 : :
1677 : 0 : static void ipip6_dellink(struct net_device *dev, struct list_head *head)
1678 : : {
1679 : : struct net *net = dev_net(dev);
1680 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1681 : :
1682 [ # # ]: 0 : if (dev != sitn->fb_tunnel_dev)
1683 : 0 : unregister_netdevice_queue(dev, head);
1684 : 0 : }
1685 : :
1686 : : static struct rtnl_link_ops sit_link_ops __read_mostly = {
1687 : : .kind = "sit",
1688 : : .maxtype = IFLA_IPTUN_MAX,
1689 : : .policy = ipip6_policy,
1690 : : .priv_size = sizeof(struct ip_tunnel),
1691 : : .setup = ipip6_tunnel_setup,
1692 : : .validate = ipip6_validate,
1693 : : .newlink = ipip6_newlink,
1694 : : .changelink = ipip6_changelink,
1695 : : .get_size = ipip6_get_size,
1696 : : .fill_info = ipip6_fill_info,
1697 : : .dellink = ipip6_dellink,
1698 : : };
1699 : :
1700 : : static struct xfrm_tunnel sit_handler __read_mostly = {
1701 : : .handler = ipip6_rcv,
1702 : : .err_handler = ipip6_err,
1703 : : .priority = 1,
1704 : : };
1705 : :
1706 : : static struct xfrm_tunnel ipip_handler __read_mostly = {
1707 : : .handler = ipip_rcv,
1708 : : .err_handler = ipip6_err,
1709 : : .priority = 2,
1710 : : };
1711 : :
1712 : 0 : static void __net_exit sit_destroy_tunnels(struct net *net,
1713 : : struct list_head *head)
1714 : : {
1715 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1716 : : struct net_device *dev, *aux;
1717 : : int prio;
1718 : :
1719 [ # # ]: 0 : for_each_netdev_safe(net, dev, aux)
1720 [ # # ]: 0 : if (dev->rtnl_link_ops == &sit_link_ops)
1721 : 0 : unregister_netdevice_queue(dev, head);
1722 : :
1723 [ # # ]: 0 : for (prio = 1; prio < 4; prio++) {
1724 : : int h;
1725 [ # # ]: 0 : for (h = 0; h < HASH_SIZE; h++) {
1726 : : struct ip_tunnel *t;
1727 : :
1728 : 0 : t = rtnl_dereference(sitn->tunnels[prio][h]);
1729 [ # # ]: 0 : while (t != NULL) {
1730 : : /* If dev is in the same netns, it has already
1731 : : * been added to the list by the previous loop.
1732 : : */
1733 : : if (!net_eq(dev_net(t->dev), net))
1734 : : unregister_netdevice_queue(t->dev,
1735 : : head);
1736 : 0 : t = rtnl_dereference(t->next);
1737 : : }
1738 : : }
1739 : : }
1740 : 0 : }
1741 : :
1742 : 0 : static int __net_init sit_init_net(struct net *net)
1743 : : {
1744 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1745 : : struct ip_tunnel *t;
1746 : : int err;
1747 : :
1748 : 0 : sitn->tunnels[0] = sitn->tunnels_wc;
1749 : 0 : sitn->tunnels[1] = sitn->tunnels_l;
1750 : 0 : sitn->tunnels[2] = sitn->tunnels_r;
1751 : 0 : sitn->tunnels[3] = sitn->tunnels_r_l;
1752 : :
1753 : 0 : sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
1754 : : ipip6_tunnel_setup);
1755 [ # # ]: 0 : if (!sitn->fb_tunnel_dev) {
1756 : : err = -ENOMEM;
1757 : : goto err_alloc_dev;
1758 : : }
1759 : : dev_net_set(sitn->fb_tunnel_dev, net);
1760 : 0 : sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
1761 : : /* FB netdevice is special: we have one, and only one per netns.
1762 : : * Allowing to move it to another netns is clearly unsafe.
1763 : : */
1764 : 0 : sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1765 : :
1766 : 0 : err = ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
1767 [ # # ]: 0 : if (err)
1768 : : goto err_dev_free;
1769 : :
1770 : : ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1771 : :
1772 [ # # ]: 0 : if ((err = register_netdev(sitn->fb_tunnel_dev)))
1773 : : goto err_reg_dev;
1774 : :
1775 : 0 : t = netdev_priv(sitn->fb_tunnel_dev);
1776 : :
1777 : 0 : strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
1778 : 0 : return 0;
1779 : :
1780 : : err_reg_dev:
1781 : 0 : dev_put(sitn->fb_tunnel_dev);
1782 : : err_dev_free:
1783 : 0 : ipip6_dev_free(sitn->fb_tunnel_dev);
1784 : : err_alloc_dev:
1785 : 0 : return err;
1786 : : }
1787 : :
1788 : 0 : static void __net_exit sit_exit_net(struct net *net)
1789 : : {
1790 : 0 : LIST_HEAD(list);
1791 : :
1792 : 0 : rtnl_lock();
1793 : 0 : sit_destroy_tunnels(net, &list);
1794 : 0 : unregister_netdevice_many(&list);
1795 : 0 : rtnl_unlock();
1796 : 0 : }
1797 : :
1798 : : static struct pernet_operations sit_net_ops = {
1799 : : .init = sit_init_net,
1800 : : .exit = sit_exit_net,
1801 : : .id = &sit_net_id,
1802 : : .size = sizeof(struct sit_net),
1803 : : };
1804 : :
1805 : 0 : static void __exit sit_cleanup(void)
1806 : : {
1807 : 0 : rtnl_link_unregister(&sit_link_ops);
1808 : 0 : xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1809 : 0 : xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1810 : :
1811 : 0 : unregister_pernet_device(&sit_net_ops);
1812 : 0 : rcu_barrier(); /* Wait for completion of call_rcu()'s */
1813 : 0 : }
1814 : :
1815 : 0 : static int __init sit_init(void)
1816 : : {
1817 : : int err;
1818 : :
1819 : 0 : pr_info("IPv6 over IPv4 tunneling driver\n");
1820 : :
1821 : 0 : err = register_pernet_device(&sit_net_ops);
1822 [ # # ]: 0 : if (err < 0)
1823 : : return err;
1824 : 0 : err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
1825 [ # # ]: 0 : if (err < 0) {
1826 : 0 : pr_info("%s: can't register ip6ip4\n", __func__);
1827 : 0 : goto xfrm_tunnel_failed;
1828 : : }
1829 : 0 : err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1830 [ # # ]: 0 : if (err < 0) {
1831 : 0 : pr_info("%s: can't register ip4ip4\n", __func__);
1832 : 0 : goto xfrm_tunnel4_failed;
1833 : : }
1834 : 0 : err = rtnl_link_register(&sit_link_ops);
1835 [ # # ]: 0 : if (err < 0)
1836 : : goto rtnl_link_failed;
1837 : :
1838 : : out:
1839 : 0 : return err;
1840 : :
1841 : : rtnl_link_failed:
1842 : 0 : xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1843 : : xfrm_tunnel4_failed:
1844 : 0 : xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1845 : : xfrm_tunnel_failed:
1846 : 0 : unregister_pernet_device(&sit_net_ops);
1847 : 0 : goto out;
1848 : : }
1849 : :
1850 : : module_init(sit_init);
1851 : : module_exit(sit_cleanup);
1852 : : MODULE_LICENSE("GPL");
1853 : : MODULE_ALIAS_NETDEV("sit0");
|
