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 : : 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 : : dev_put(dev);
479 : 0 : }
480 : :
481 : : /* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
482 : : * if sufficient data bytes are available
483 : : */
484 : 0 : static int ipip6_err_gen_icmpv6_unreach(struct sk_buff *skb)
485 : : {
486 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
487 : : struct rt6_info *rt;
488 : : struct sk_buff *skb2;
489 : :
490 [ # # ]: 0 : if (!pskb_may_pull(skb, iph->ihl * 4 + sizeof(struct ipv6hdr) + 8))
491 : : return 1;
492 : :
493 : 0 : skb2 = skb_clone(skb, GFP_ATOMIC);
494 : :
495 [ # # ]: 0 : if (!skb2)
496 : : return 1;
497 : :
498 : : skb_dst_drop(skb2);
499 : 0 : skb_pull(skb2, iph->ihl * 4);
500 : : skb_reset_network_header(skb2);
501 : :
502 : 0 : rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0, 0);
503 : :
504 [ # # ][ # # ]: 0 : if (rt && rt->dst.dev)
505 : 0 : skb2->dev = rt->dst.dev;
506 : :
507 : 0 : icmpv6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
508 : :
509 [ # # ]: 0 : if (rt)
510 : : ip6_rt_put(rt);
511 : :
512 : 0 : kfree_skb(skb2);
513 : :
514 : 0 : return 0;
515 : : }
516 : :
517 : 0 : static int ipip6_err(struct sk_buff *skb, u32 info)
518 : : {
519 : 0 : const struct iphdr *iph = (const struct iphdr *)skb->data;
520 : 0 : const int type = icmp_hdr(skb)->type;
521 : 0 : const int code = icmp_hdr(skb)->code;
522 : : struct ip_tunnel *t;
523 : : int err;
524 : :
525 [ # # # # ]: 0 : switch (type) {
526 : : default:
527 : : case ICMP_PARAMETERPROB:
528 : : return 0;
529 : :
530 : : case ICMP_DEST_UNREACH:
531 [ # # ]: 0 : switch (code) {
532 : : case ICMP_SR_FAILED:
533 : : /* Impossible event. */
534 : : return 0;
535 : : default:
536 : : /* All others are translated to HOST_UNREACH.
537 : : rfc2003 contains "deep thoughts" about NET_UNREACH,
538 : : I believe they are just ether pollution. --ANK
539 : : */
540 : : break;
541 : : }
542 : : break;
543 : : case ICMP_TIME_EXCEEDED:
544 [ # # ]: 0 : if (code != ICMP_EXC_TTL)
545 : : return 0;
546 : : break;
547 : : case ICMP_REDIRECT:
548 : : break;
549 : : }
550 : :
551 : : err = -ENOENT;
552 : :
553 : 0 : t = ipip6_tunnel_lookup(dev_net(skb->dev),
554 : : skb->dev,
555 : : iph->daddr,
556 : : iph->saddr);
557 [ # # ]: 0 : if (t == NULL)
558 : : goto out;
559 : :
560 [ # # ]: 0 : if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
561 : 0 : ipv4_update_pmtu(skb, dev_net(skb->dev), info,
562 : 0 : t->dev->ifindex, 0, IPPROTO_IPV6, 0);
563 : : err = 0;
564 : 0 : goto out;
565 : : }
566 [ # # ]: 0 : if (type == ICMP_REDIRECT) {
567 : 0 : ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
568 : : IPPROTO_IPV6, 0);
569 : : err = 0;
570 : 0 : goto out;
571 : : }
572 : :
573 [ # # ]: 0 : if (t->parms.iph.daddr == 0)
574 : : goto out;
575 : :
576 : : err = 0;
577 [ # # ]: 0 : if (!ipip6_err_gen_icmpv6_unreach(skb))
578 : : goto out;
579 : :
580 [ # # ][ # # ]: 0 : if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
581 : : goto out;
582 : :
583 [ # # ]: 0 : if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
584 : 0 : t->err_count++;
585 : : else
586 : 0 : t->err_count = 1;
587 : 0 : t->err_time = jiffies;
588 : : out:
589 : 0 : return err;
590 : : }
591 : :
592 : : static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
593 : : const struct in6_addr *v6addr)
594 : : {
595 : 0 : __be32 v4embed = 0;
596 [ # # ][ # # ]: 0 : if (check_6rd(tunnel, v6addr, &v4embed) && v4addr != v4embed)
[ # # ][ # # ]
597 : : return true;
598 : : return false;
599 : : }
600 : :
601 : : /* Checks if an address matches an address on the tunnel interface.
602 : : * Used to detect the NAT of proto 41 packets and let them pass spoofing test.
603 : : * Long story:
604 : : * This function is called after we considered the packet as spoofed
605 : : * in is_spoofed_6rd.
606 : : * We may have a router that is doing NAT for proto 41 packets
607 : : * for an internal station. Destination a.a.a.a/PREFIX:bbbb:bbbb
608 : : * will be translated to n.n.n.n/PREFIX:bbbb:bbbb. And is_spoofed_6rd
609 : : * function will return true, dropping the packet.
610 : : * But, we can still check if is spoofed against the IP
611 : : * addresses associated with the interface.
612 : : */
613 : : static bool only_dnatted(const struct ip_tunnel *tunnel,
614 : : const struct in6_addr *v6dst)
615 : : {
616 : : int prefix_len;
617 : :
618 : : #ifdef CONFIG_IPV6_SIT_6RD
619 : : prefix_len = tunnel->ip6rd.prefixlen + 32
620 : : - tunnel->ip6rd.relay_prefixlen;
621 : : #else
622 : : prefix_len = 48;
623 : : #endif
624 : 0 : return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
625 : : }
626 : :
627 : : /* Returns true if a packet is spoofed */
628 : 0 : static bool packet_is_spoofed(struct sk_buff *skb,
629 : : const struct iphdr *iph,
630 : 0 : struct ip_tunnel *tunnel)
631 : : {
632 : : const struct ipv6hdr *ipv6h;
633 : :
634 [ # # ]: 0 : if (tunnel->dev->priv_flags & IFF_ISATAP) {
635 [ # # ]: 0 : if (!isatap_chksrc(skb, iph, tunnel))
636 : : return true;
637 : :
638 : 0 : return false;
639 : : }
640 : :
641 [ # # ]: 0 : if (tunnel->dev->flags & IFF_POINTOPOINT)
642 : : return false;
643 : :
644 : : ipv6h = ipv6_hdr(skb);
645 : :
646 [ # # ]: 0 : if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
647 [ # # ]: 0 : net_warn_ratelimited("Src spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
648 : : &iph->saddr, &ipv6h->saddr,
649 : : &iph->daddr, &ipv6h->daddr);
650 : : return true;
651 : : }
652 : :
653 [ # # ]: 0 : if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
654 : : return false;
655 : :
656 [ # # ]: 0 : if (only_dnatted(tunnel, &ipv6h->daddr))
657 : : return false;
658 : :
659 [ # # ]: 0 : net_warn_ratelimited("Dst spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
660 : : &iph->saddr, &ipv6h->saddr,
661 : : &iph->daddr, &ipv6h->daddr);
662 : : return true;
663 : : }
664 : :
665 : 0 : static int ipip6_rcv(struct sk_buff *skb)
666 : : {
667 : : const struct iphdr *iph = ip_hdr(skb);
668 : : struct ip_tunnel *tunnel;
669 : : int err;
670 : :
671 : 0 : tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
672 : : iph->saddr, iph->daddr);
673 [ # # ]: 0 : if (tunnel != NULL) {
674 : : struct pcpu_tstats *tstats;
675 : :
676 [ # # ]: 0 : if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
677 : : tunnel->parms.iph.protocol != 0)
678 : : goto out;
679 : :
680 : 0 : skb->mac_header = skb->network_header;
681 : : skb_reset_network_header(skb);
682 : 0 : IPCB(skb)->flags = 0;
683 : 0 : skb->protocol = htons(ETH_P_IPV6);
684 : :
685 [ # # ]: 0 : if (packet_is_spoofed(skb, iph, tunnel)) {
686 : 0 : tunnel->dev->stats.rx_errors++;
687 : 0 : goto out;
688 : : }
689 : :
690 : 0 : __skb_tunnel_rx(skb, tunnel->dev, tunnel->net);
691 : :
692 : : err = IP_ECN_decapsulate(iph, skb);
693 [ # # ]: 0 : if (unlikely(err)) {
694 [ # # ]: 0 : if (log_ecn_error)
695 [ # # ]: 0 : net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
696 : : &iph->saddr, iph->tos);
697 [ # # ]: 0 : if (err > 1) {
698 : 0 : ++tunnel->dev->stats.rx_frame_errors;
699 : 0 : ++tunnel->dev->stats.rx_errors;
700 : 0 : goto out;
701 : : }
702 : : }
703 : :
704 : 0 : tstats = this_cpu_ptr(tunnel->dev->tstats);
705 : : u64_stats_update_begin(&tstats->syncp);
706 : 0 : tstats->rx_packets++;
707 : 0 : tstats->rx_bytes += skb->len;
708 : : u64_stats_update_end(&tstats->syncp);
709 : :
710 : 0 : netif_rx(skb);
711 : :
712 : 0 : return 0;
713 : : }
714 : :
715 : : /* no tunnel matched, let upstream know, ipsec may handle it */
716 : : return 1;
717 : : out:
718 : 0 : kfree_skb(skb);
719 : 0 : return 0;
720 : : }
721 : :
722 : : static const struct tnl_ptk_info tpi = {
723 : : /* no tunnel info required for ipip. */
724 : : .proto = htons(ETH_P_IP),
725 : : };
726 : :
727 : 0 : static int ipip_rcv(struct sk_buff *skb)
728 : : {
729 : : const struct iphdr *iph;
730 : : struct ip_tunnel *tunnel;
731 : :
732 : : iph = ip_hdr(skb);
733 : 0 : tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
734 : : iph->saddr, iph->daddr);
735 [ # # ]: 0 : if (tunnel != NULL) {
736 [ # # ]: 0 : if (tunnel->parms.iph.protocol != IPPROTO_IPIP &&
737 : : tunnel->parms.iph.protocol != 0)
738 : : goto drop;
739 : :
740 [ # # ]: 0 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
741 : : goto drop;
742 [ # # ]: 0 : if (iptunnel_pull_header(skb, 0, tpi.proto))
743 : : goto drop;
744 : 0 : return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
745 : : }
746 : :
747 : : return 1;
748 : :
749 : : drop:
750 : 0 : kfree_skb(skb);
751 : 0 : return 0;
752 : : }
753 : :
754 : : /*
755 : : * If the IPv6 address comes from 6rd / 6to4 (RFC 3056) addr space this function
756 : : * stores the embedded IPv4 address in v4dst and returns true.
757 : : */
758 : 0 : static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
759 : : __be32 *v4dst)
760 : : {
761 : : #ifdef CONFIG_IPV6_SIT_6RD
762 : : if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
763 : : tunnel->ip6rd.prefixlen)) {
764 : : unsigned int pbw0, pbi0;
765 : : int pbi1;
766 : : u32 d;
767 : :
768 : : pbw0 = tunnel->ip6rd.prefixlen >> 5;
769 : : pbi0 = tunnel->ip6rd.prefixlen & 0x1f;
770 : :
771 : : d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
772 : : tunnel->ip6rd.relay_prefixlen;
773 : :
774 : : pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
775 : : if (pbi1 > 0)
776 : : d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
777 : : (32 - pbi1);
778 : :
779 : : *v4dst = tunnel->ip6rd.relay_prefix | htonl(d);
780 : : return true;
781 : : }
782 : : #else
783 [ # # ]: 0 : if (v6dst->s6_addr16[0] == htons(0x2002)) {
784 : : /* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
785 : 0 : memcpy(v4dst, &v6dst->s6_addr16[1], 4);
786 : : return true;
787 : : }
788 : : #endif
789 : : return false;
790 : : }
791 : :
792 : : static inline __be32 try_6rd(struct ip_tunnel *tunnel,
793 : : const struct in6_addr *v6dst)
794 : : {
795 : 0 : __be32 dst = 0;
796 : 0 : check_6rd(tunnel, v6dst, &dst);
797 : 0 : return dst;
798 : : }
799 : :
800 : : /*
801 : : * This function assumes it is being called from dev_queue_xmit()
802 : : * and that skb is filled properly by that function.
803 : : */
804 : :
805 : 0 : static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
806 : : struct net_device *dev)
807 : : {
808 : : struct ip_tunnel *tunnel = netdev_priv(dev);
809 : : const struct iphdr *tiph = &tunnel->parms.iph;
810 : : const struct ipv6hdr *iph6 = ipv6_hdr(skb);
811 : 0 : u8 tos = tunnel->parms.iph.tos;
812 : 0 : __be16 df = tiph->frag_off;
813 : : struct rtable *rt; /* Route to the other host */
814 : : struct net_device *tdev; /* Device to other host */
815 : : unsigned int max_headroom; /* The extra header space needed */
816 : 0 : __be32 dst = tiph->daddr;
817 : : struct flowi4 fl4;
818 : : int mtu;
819 : 0 : const struct in6_addr *addr6;
820 : : int addr_type;
821 : : u8 ttl;
822 : : int err;
823 : :
824 [ # # ]: 0 : if (skb->protocol != htons(ETH_P_IPV6))
825 : : goto tx_error;
826 : :
827 [ # # ]: 0 : if (tos == 1)
828 : : tos = ipv6_get_dsfield(iph6);
829 : :
830 : : /* ISATAP (RFC4214) - must come before 6to4 */
831 [ # # ]: 0 : if (dev->priv_flags & IFF_ISATAP) {
832 : : struct neighbour *neigh = NULL;
833 : : bool do_tx_error = false;
834 : :
835 [ # # ]: 0 : if (skb_dst(skb))
836 : 0 : neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
837 : :
838 [ # # ]: 0 : if (neigh == NULL) {
839 : 0 : net_dbg_ratelimited("nexthop == NULL\n");
840 : : goto tx_error;
841 : : }
842 : :
843 : 0 : addr6 = (const struct in6_addr *)&neigh->primary_key;
844 : : addr_type = ipv6_addr_type(addr6);
845 : :
846 [ # # ][ # # ]: 0 : if ((addr_type & IPV6_ADDR_UNICAST) &&
847 : : ipv6_addr_is_isatap(addr6))
848 : 0 : dst = addr6->s6_addr32[3];
849 : : else
850 : : do_tx_error = true;
851 : :
852 : : neigh_release(neigh);
853 [ # # ]: 0 : if (do_tx_error)
854 : : goto tx_error;
855 : : }
856 : :
857 [ # # ]: 0 : if (!dst)
858 : 0 : dst = try_6rd(tunnel, &iph6->daddr);
859 : :
860 [ # # ]: 0 : if (!dst) {
861 : : struct neighbour *neigh = NULL;
862 : : bool do_tx_error = false;
863 : :
864 [ # # ]: 0 : if (skb_dst(skb))
865 : 0 : neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
866 : :
867 [ # # ]: 0 : if (neigh == NULL) {
868 : 0 : net_dbg_ratelimited("nexthop == NULL\n");
869 : : goto tx_error;
870 : : }
871 : :
872 : 0 : addr6 = (const struct in6_addr *)&neigh->primary_key;
873 : : addr_type = ipv6_addr_type(addr6);
874 : :
875 [ # # ]: 0 : if (addr_type == IPV6_ADDR_ANY) {
876 : 0 : addr6 = &ipv6_hdr(skb)->daddr;
877 : : addr_type = ipv6_addr_type(addr6);
878 : : }
879 : :
880 [ # # ]: 0 : if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
881 : 0 : dst = addr6->s6_addr32[3];
882 : : else
883 : : do_tx_error = true;
884 : :
885 : : neigh_release(neigh);
886 [ # # ]: 0 : if (do_tx_error)
887 : : goto tx_error;
888 : : }
889 : :
890 : 0 : rt = ip_route_output_ports(tunnel->net, &fl4, NULL,
891 : : dst, tiph->saddr,
892 : : 0, 0,
893 : : IPPROTO_IPV6, RT_TOS(tos),
894 : : tunnel->parms.link);
895 [ # # ]: 0 : if (IS_ERR(rt)) {
896 : 0 : dev->stats.tx_carrier_errors++;
897 : 0 : goto tx_error_icmp;
898 : : }
899 [ # # ]: 0 : if (rt->rt_type != RTN_UNICAST) {
900 : : ip_rt_put(rt);
901 : 0 : dev->stats.tx_carrier_errors++;
902 : 0 : goto tx_error_icmp;
903 : : }
904 : 0 : tdev = rt->dst.dev;
905 : :
906 [ # # ]: 0 : if (tdev == dev) {
907 : : ip_rt_put(rt);
908 : 0 : dev->stats.collisions++;
909 : 0 : goto tx_error;
910 : : }
911 : :
912 [ # # ]: 0 : if (df) {
913 : 0 : mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
914 : :
915 [ # # ]: 0 : if (mtu < 68) {
916 : 0 : dev->stats.collisions++;
917 : : ip_rt_put(rt);
918 : : goto tx_error;
919 : : }
920 : :
921 [ # # ]: 0 : if (mtu < IPV6_MIN_MTU) {
922 : : mtu = IPV6_MIN_MTU;
923 : : df = 0;
924 : : }
925 : :
926 [ # # ][ # # ]: 0 : if (tunnel->parms.iph.daddr && skb_dst(skb))
927 : 0 : skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
928 : :
929 [ # # ][ # # ]: 0 : if (skb->len > mtu && !skb_is_gso(skb)) {
930 : 0 : icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
931 : : ip_rt_put(rt);
932 : : goto tx_error;
933 : : }
934 : : }
935 : :
936 [ # # ]: 0 : if (tunnel->err_count > 0) {
937 [ # # ]: 0 : if (time_before(jiffies,
938 : : tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
939 : 0 : tunnel->err_count--;
940 : : dst_link_failure(skb);
941 : : } else
942 : 0 : tunnel->err_count = 0;
943 : : }
944 : :
945 : : /*
946 : : * Okay, now see if we can stuff it in the buffer as-is.
947 : : */
948 : 0 : max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);
949 : :
950 [ # # ][ # # ]: 0 : if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
[ # # ]
951 [ # # ]: 0 : (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
952 : 0 : struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
953 [ # # ]: 0 : if (!new_skb) {
954 : : ip_rt_put(rt);
955 : 0 : dev->stats.tx_dropped++;
956 : 0 : kfree_skb(skb);
957 : 0 : return NETDEV_TX_OK;
958 : : }
959 [ # # ]: 0 : if (skb->sk)
960 : : skb_set_owner_w(new_skb, skb->sk);
961 : 0 : dev_kfree_skb(skb);
962 : : skb = new_skb;
963 : : iph6 = ipv6_hdr(skb);
964 : : }
965 : 0 : ttl = tiph->ttl;
966 [ # # ]: 0 : if (ttl == 0)
967 : 0 : ttl = iph6->hop_limit;
968 : : tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
969 : :
970 : 0 : skb = iptunnel_handle_offloads(skb, false, SKB_GSO_SIT);
971 [ # # ]: 0 : if (IS_ERR(skb)) {
972 : : ip_rt_put(rt);
973 : : goto out;
974 : : }
975 : :
976 : 0 : err = iptunnel_xmit(rt, skb, fl4.saddr, fl4.daddr, IPPROTO_IPV6, tos,
977 : : ttl, df, !net_eq(tunnel->net, dev_net(dev)));
978 : 0 : iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
979 : : return NETDEV_TX_OK;
980 : :
981 : : tx_error_icmp:
982 : : dst_link_failure(skb);
983 : : tx_error:
984 : 0 : kfree_skb(skb);
985 : : out:
986 : 0 : dev->stats.tx_errors++;
987 : 0 : return NETDEV_TX_OK;
988 : : }
989 : :
990 : 0 : static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
991 : : {
992 : : struct ip_tunnel *tunnel = netdev_priv(dev);
993 : 0 : const struct iphdr *tiph = &tunnel->parms.iph;
994 : :
995 : 0 : skb = iptunnel_handle_offloads(skb, false, SKB_GSO_IPIP);
996 [ # # ]: 0 : if (IS_ERR(skb))
997 : : goto out;
998 : :
999 : 0 : ip_tunnel_xmit(skb, dev, tiph, IPPROTO_IPIP);
1000 : 0 : return NETDEV_TX_OK;
1001 : : out:
1002 : 0 : dev->stats.tx_errors++;
1003 : 0 : return NETDEV_TX_OK;
1004 : : }
1005 : :
1006 : 0 : static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
1007 : : struct net_device *dev)
1008 : : {
1009 [ # # # ]: 0 : switch (skb->protocol) {
1010 : : case htons(ETH_P_IP):
1011 : 0 : ipip_tunnel_xmit(skb, dev);
1012 : 0 : break;
1013 : : case htons(ETH_P_IPV6):
1014 : 0 : ipip6_tunnel_xmit(skb, dev);
1015 : 0 : break;
1016 : : default:
1017 : : goto tx_err;
1018 : : }
1019 : :
1020 : : return NETDEV_TX_OK;
1021 : :
1022 : : tx_err:
1023 : 0 : dev->stats.tx_errors++;
1024 : 0 : kfree_skb(skb);
1025 : 0 : return NETDEV_TX_OK;
1026 : :
1027 : : }
1028 : :
1029 : 0 : static void ipip6_tunnel_bind_dev(struct net_device *dev)
1030 : : {
1031 : : struct net_device *tdev = NULL;
1032 : : struct ip_tunnel *tunnel;
1033 : : const struct iphdr *iph;
1034 : : struct flowi4 fl4;
1035 : :
1036 : : tunnel = netdev_priv(dev);
1037 : : iph = &tunnel->parms.iph;
1038 : :
1039 [ # # ]: 0 : if (iph->daddr) {
1040 : 0 : struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
1041 : : NULL,
1042 : : iph->daddr, iph->saddr,
1043 : : 0, 0,
1044 : : IPPROTO_IPV6,
1045 : 0 : RT_TOS(iph->tos),
1046 : : tunnel->parms.link);
1047 : :
1048 [ # # ]: 0 : if (!IS_ERR(rt)) {
1049 : 0 : tdev = rt->dst.dev;
1050 : : ip_rt_put(rt);
1051 : : }
1052 : 0 : dev->flags |= IFF_POINTOPOINT;
1053 : : }
1054 : :
1055 [ # # ][ # # ]: 0 : if (!tdev && tunnel->parms.link)
1056 : 0 : tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
1057 : :
1058 [ # # ]: 0 : if (tdev) {
1059 : 0 : dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
1060 : 0 : dev->mtu = tdev->mtu - sizeof(struct iphdr);
1061 [ # # ]: 0 : if (dev->mtu < IPV6_MIN_MTU)
1062 : 0 : dev->mtu = IPV6_MIN_MTU;
1063 : : }
1064 : 0 : dev->iflink = tunnel->parms.link;
1065 : 0 : }
1066 : :
1067 : 0 : static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
1068 : : {
1069 : 0 : struct net *net = t->net;
1070 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1071 : :
1072 : 0 : ipip6_tunnel_unlink(sitn, t);
1073 : 0 : synchronize_net();
1074 : 0 : t->parms.iph.saddr = p->iph.saddr;
1075 : 0 : t->parms.iph.daddr = p->iph.daddr;
1076 : 0 : memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
1077 : 0 : memcpy(t->dev->broadcast, &p->iph.daddr, 4);
1078 : 0 : ipip6_tunnel_link(sitn, t);
1079 : 0 : t->parms.iph.ttl = p->iph.ttl;
1080 : 0 : t->parms.iph.tos = p->iph.tos;
1081 [ # # ]: 0 : if (t->parms.link != p->link) {
1082 : 0 : t->parms.link = p->link;
1083 : 0 : ipip6_tunnel_bind_dev(t->dev);
1084 : : }
1085 : 0 : netdev_state_change(t->dev);
1086 : 0 : }
1087 : :
1088 : : #ifdef CONFIG_IPV6_SIT_6RD
1089 : : static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
1090 : : struct ip_tunnel_6rd *ip6rd)
1091 : : {
1092 : : struct in6_addr prefix;
1093 : : __be32 relay_prefix;
1094 : :
1095 : : if (ip6rd->relay_prefixlen > 32 ||
1096 : : ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
1097 : : return -EINVAL;
1098 : :
1099 : : ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
1100 : : if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
1101 : : return -EINVAL;
1102 : : if (ip6rd->relay_prefixlen)
1103 : : relay_prefix = ip6rd->relay_prefix &
1104 : : htonl(0xffffffffUL <<
1105 : : (32 - ip6rd->relay_prefixlen));
1106 : : else
1107 : : relay_prefix = 0;
1108 : : if (relay_prefix != ip6rd->relay_prefix)
1109 : : return -EINVAL;
1110 : :
1111 : : t->ip6rd.prefix = prefix;
1112 : : t->ip6rd.relay_prefix = relay_prefix;
1113 : : t->ip6rd.prefixlen = ip6rd->prefixlen;
1114 : : t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
1115 : : netdev_state_change(t->dev);
1116 : : return 0;
1117 : : }
1118 : : #endif
1119 : :
1120 : : static int
1121 : 0 : ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
1122 : : {
1123 : : int err = 0;
1124 : : struct ip_tunnel_parm p;
1125 : : struct ip_tunnel_prl prl;
1126 : : struct ip_tunnel *t;
1127 : : struct net *net = dev_net(dev);
1128 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1129 : : #ifdef CONFIG_IPV6_SIT_6RD
1130 : : struct ip_tunnel_6rd ip6rd;
1131 : : #endif
1132 : :
1133 [ # # # # : 0 : switch (cmd) {
# # ]
1134 : : case SIOCGETTUNNEL:
1135 : : #ifdef CONFIG_IPV6_SIT_6RD
1136 : : case SIOCGET6RD:
1137 : : #endif
1138 : : t = NULL;
1139 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev) {
1140 [ # # ]: 0 : if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1141 : : err = -EFAULT;
1142 : : break;
1143 : : }
1144 : 0 : t = ipip6_tunnel_locate(net, &p, 0);
1145 : : }
1146 [ # # ]: 0 : if (t == NULL)
1147 : 0 : t = netdev_priv(dev);
1148 : :
1149 : : err = -EFAULT;
1150 [ # # ]: 0 : if (cmd == SIOCGETTUNNEL) {
1151 : 0 : memcpy(&p, &t->parms, sizeof(p));
1152 [ # # ]: 0 : if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
1153 : : sizeof(p)))
1154 : : goto done;
1155 : : #ifdef CONFIG_IPV6_SIT_6RD
1156 : : } else {
1157 : : ip6rd.prefix = t->ip6rd.prefix;
1158 : : ip6rd.relay_prefix = t->ip6rd.relay_prefix;
1159 : : ip6rd.prefixlen = t->ip6rd.prefixlen;
1160 : : ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
1161 : : if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
1162 : : sizeof(ip6rd)))
1163 : : goto done;
1164 : : #endif
1165 : : }
1166 : : err = 0;
1167 : : break;
1168 : :
1169 : : case SIOCADDTUNNEL:
1170 : : case SIOCCHGTUNNEL:
1171 : : err = -EPERM;
1172 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1173 : : goto done;
1174 : :
1175 : : err = -EFAULT;
1176 [ # # ]: 0 : if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1177 : : goto done;
1178 : :
1179 : : err = -EINVAL;
1180 [ # # ]: 0 : if (p.iph.protocol != IPPROTO_IPV6 &&
1181 [ # # ]: 0 : p.iph.protocol != IPPROTO_IPIP &&
1182 : : p.iph.protocol != 0)
1183 : : goto done;
1184 [ # # ]: 0 : if (p.iph.version != 4 ||
1185 [ # # ]: 0 : p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
1186 : : goto done;
1187 [ # # ]: 0 : if (p.iph.ttl)
1188 : 0 : p.iph.frag_off |= htons(IP_DF);
1189 : :
1190 : 0 : t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1191 : :
1192 [ # # ][ # # ]: 0 : if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1193 [ # # ]: 0 : if (t != NULL) {
1194 [ # # ]: 0 : if (t->dev != dev) {
1195 : : err = -EEXIST;
1196 : : break;
1197 : : }
1198 : : } else {
1199 [ # # ][ # # ]: 0 : if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
[ # # ]
1200 [ # # ]: 0 : (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
1201 : : err = -EINVAL;
1202 : : break;
1203 : : }
1204 : 0 : t = netdev_priv(dev);
1205 : : }
1206 : :
1207 : 0 : ipip6_tunnel_update(t, &p);
1208 : : }
1209 : :
1210 [ # # ]: 0 : if (t) {
1211 : : err = 0;
1212 [ # # ]: 0 : if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1213 : : err = -EFAULT;
1214 : : } else
1215 [ # # ]: 0 : err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1216 : : break;
1217 : :
1218 : : case SIOCDELTUNNEL:
1219 : : err = -EPERM;
1220 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1221 : : goto done;
1222 : :
1223 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev) {
1224 : : err = -EFAULT;
1225 [ # # ]: 0 : if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1226 : : goto done;
1227 : : err = -ENOENT;
1228 [ # # ]: 0 : if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL)
1229 : : goto done;
1230 : : err = -EPERM;
1231 [ # # ]: 0 : if (t == netdev_priv(sitn->fb_tunnel_dev))
1232 : : goto done;
1233 : 0 : dev = t->dev;
1234 : : }
1235 : : unregister_netdevice(dev);
1236 : : err = 0;
1237 : 0 : break;
1238 : :
1239 : : case SIOCGETPRL:
1240 : : err = -EINVAL;
1241 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev)
1242 : : goto done;
1243 : : err = -ENOENT;
1244 [ # # ]: 0 : if (!(t = netdev_priv(dev)))
1245 : : goto done;
1246 : 0 : err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
1247 : 0 : break;
1248 : :
1249 : : case SIOCADDPRL:
1250 : : case SIOCDELPRL:
1251 : : case SIOCCHGPRL:
1252 : : err = -EPERM;
1253 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1254 : : goto done;
1255 : : err = -EINVAL;
1256 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev)
1257 : : goto done;
1258 : : err = -EFAULT;
1259 [ # # ]: 0 : if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
1260 : : goto done;
1261 : : err = -ENOENT;
1262 [ # # ]: 0 : if (!(t = netdev_priv(dev)))
1263 : : goto done;
1264 : :
1265 [ # # # ]: 0 : switch (cmd) {
1266 : : case SIOCDELPRL:
1267 : 0 : err = ipip6_tunnel_del_prl(t, &prl);
1268 : 0 : break;
1269 : : case SIOCADDPRL:
1270 : : case SIOCCHGPRL:
1271 : 0 : err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
1272 : 0 : break;
1273 : : }
1274 : 0 : netdev_state_change(dev);
1275 : 0 : break;
1276 : :
1277 : : #ifdef CONFIG_IPV6_SIT_6RD
1278 : : case SIOCADD6RD:
1279 : : case SIOCCHG6RD:
1280 : : case SIOCDEL6RD:
1281 : : err = -EPERM;
1282 : : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1283 : : goto done;
1284 : :
1285 : : err = -EFAULT;
1286 : : if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
1287 : : sizeof(ip6rd)))
1288 : : goto done;
1289 : :
1290 : : t = netdev_priv(dev);
1291 : :
1292 : : if (cmd != SIOCDEL6RD) {
1293 : : err = ipip6_tunnel_update_6rd(t, &ip6rd);
1294 : : if (err < 0)
1295 : : goto done;
1296 : : } else
1297 : : ipip6_tunnel_clone_6rd(dev, sitn);
1298 : :
1299 : : err = 0;
1300 : : break;
1301 : : #endif
1302 : :
1303 : : default:
1304 : : err = -EINVAL;
1305 : : }
1306 : :
1307 : : done:
1308 : 0 : return err;
1309 : : }
1310 : :
1311 : 0 : static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1312 : : {
1313 [ # # ]: 0 : if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
1314 : : return -EINVAL;
1315 : 0 : dev->mtu = new_mtu;
1316 : 0 : return 0;
1317 : : }
1318 : :
1319 : : static const struct net_device_ops ipip6_netdev_ops = {
1320 : : .ndo_uninit = ipip6_tunnel_uninit,
1321 : : .ndo_start_xmit = sit_tunnel_xmit,
1322 : : .ndo_do_ioctl = ipip6_tunnel_ioctl,
1323 : : .ndo_change_mtu = ipip6_tunnel_change_mtu,
1324 : : .ndo_get_stats64 = ip_tunnel_get_stats64,
1325 : : };
1326 : :
1327 : 0 : static void ipip6_dev_free(struct net_device *dev)
1328 : : {
1329 : 0 : free_percpu(dev->tstats);
1330 : 0 : free_netdev(dev);
1331 : 0 : }
1332 : :
1333 : : #define SIT_FEATURES (NETIF_F_SG | \
1334 : : NETIF_F_FRAGLIST | \
1335 : : NETIF_F_HIGHDMA | \
1336 : : NETIF_F_GSO_SOFTWARE | \
1337 : : NETIF_F_HW_CSUM)
1338 : :
1339 : 0 : static void ipip6_tunnel_setup(struct net_device *dev)
1340 : : {
1341 : 0 : dev->netdev_ops = &ipip6_netdev_ops;
1342 : 0 : dev->destructor = ipip6_dev_free;
1343 : :
1344 : 0 : dev->type = ARPHRD_SIT;
1345 : 0 : dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
1346 : 0 : dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
1347 : 0 : dev->flags = IFF_NOARP;
1348 : 0 : dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1349 : 0 : dev->iflink = 0;
1350 : 0 : dev->addr_len = 4;
1351 : 0 : dev->features |= NETIF_F_LLTX;
1352 : 0 : dev->features |= SIT_FEATURES;
1353 : 0 : dev->hw_features |= SIT_FEATURES;
1354 : 0 : }
1355 : :
1356 : 0 : static int ipip6_tunnel_init(struct net_device *dev)
1357 : : {
1358 : : struct ip_tunnel *tunnel = netdev_priv(dev);
1359 : : int i;
1360 : :
1361 : 0 : tunnel->dev = dev;
1362 : 0 : tunnel->net = dev_net(dev);
1363 : :
1364 : 0 : memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1365 : 0 : memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1366 : :
1367 : 0 : ipip6_tunnel_bind_dev(dev);
1368 : 0 : dev->tstats = alloc_percpu(struct pcpu_tstats);
1369 [ # # ]: 0 : if (!dev->tstats)
1370 : : return -ENOMEM;
1371 : :
1372 [ # # ]: 0 : for_each_possible_cpu(i) {
1373 : : struct pcpu_tstats *ipip6_tunnel_stats;
1374 : 0 : ipip6_tunnel_stats = per_cpu_ptr(dev->tstats, i);
1375 : : u64_stats_init(&ipip6_tunnel_stats->syncp);
1376 : : }
1377 : :
1378 : : return 0;
1379 : : }
1380 : :
1381 : 0 : static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
1382 : : {
1383 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
1384 : : struct iphdr *iph = &tunnel->parms.iph;
1385 : : struct net *net = dev_net(dev);
1386 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1387 : : int i;
1388 : :
1389 : 0 : tunnel->dev = dev;
1390 : 0 : tunnel->net = dev_net(dev);
1391 : 0 : strcpy(tunnel->parms.name, dev->name);
1392 : :
1393 : 0 : iph->version = 4;
1394 : 0 : iph->protocol = IPPROTO_IPV6;
1395 : 0 : iph->ihl = 5;
1396 : 0 : iph->ttl = 64;
1397 : :
1398 : 0 : dev->tstats = alloc_percpu(struct pcpu_tstats);
1399 [ # # ]: 0 : if (!dev->tstats)
1400 : : return -ENOMEM;
1401 : :
1402 [ # # ]: 0 : for_each_possible_cpu(i) {
1403 : : struct pcpu_tstats *ipip6_fb_stats;
1404 : 0 : ipip6_fb_stats = per_cpu_ptr(dev->tstats, i);
1405 : : u64_stats_init(&ipip6_fb_stats->syncp);
1406 : : }
1407 : :
1408 : : dev_hold(dev);
1409 : 0 : rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
1410 : 0 : return 0;
1411 : : }
1412 : :
1413 : 0 : static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[])
1414 : : {
1415 : : u8 proto;
1416 : :
1417 [ # # ][ # # ]: 0 : if (!data || !data[IFLA_IPTUN_PROTO])
1418 : : return 0;
1419 : :
1420 : : proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1421 [ # # ]: 0 : if (proto != IPPROTO_IPV6 &&
1422 [ # # ]: 0 : proto != IPPROTO_IPIP &&
1423 : : proto != 0)
1424 : : return -EINVAL;
1425 : :
1426 : 0 : return 0;
1427 : : }
1428 : :
1429 : 0 : static void ipip6_netlink_parms(struct nlattr *data[],
1430 : : struct ip_tunnel_parm *parms)
1431 : : {
1432 : 0 : memset(parms, 0, sizeof(*parms));
1433 : :
1434 : 0 : parms->iph.version = 4;
1435 : 0 : parms->iph.protocol = IPPROTO_IPV6;
1436 : 0 : parms->iph.ihl = 5;
1437 : 0 : parms->iph.ttl = 64;
1438 : :
1439 [ # # ]: 0 : if (!data)
1440 : 0 : return;
1441 : :
1442 [ # # ]: 0 : if (data[IFLA_IPTUN_LINK])
1443 : 0 : parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1444 : :
1445 [ # # ]: 0 : if (data[IFLA_IPTUN_LOCAL])
1446 : 0 : parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
1447 : :
1448 [ # # ]: 0 : if (data[IFLA_IPTUN_REMOTE])
1449 : 0 : parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
1450 : :
1451 [ # # ]: 0 : if (data[IFLA_IPTUN_TTL]) {
1452 : 0 : parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
1453 [ # # ]: 0 : if (parms->iph.ttl)
1454 : 0 : parms->iph.frag_off = htons(IP_DF);
1455 : : }
1456 : :
1457 [ # # ]: 0 : if (data[IFLA_IPTUN_TOS])
1458 : 0 : parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
1459 : :
1460 [ # # ][ # # ]: 0 : if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
1461 : 0 : parms->iph.frag_off = htons(IP_DF);
1462 : :
1463 [ # # ]: 0 : if (data[IFLA_IPTUN_FLAGS])
1464 : 0 : parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
1465 : :
1466 [ # # ]: 0 : if (data[IFLA_IPTUN_PROTO])
1467 : 0 : parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1468 : :
1469 : : }
1470 : :
1471 : : #ifdef CONFIG_IPV6_SIT_6RD
1472 : : /* This function returns true when 6RD attributes are present in the nl msg */
1473 : : static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
1474 : : struct ip_tunnel_6rd *ip6rd)
1475 : : {
1476 : : bool ret = false;
1477 : : memset(ip6rd, 0, sizeof(*ip6rd));
1478 : :
1479 : : if (!data)
1480 : : return ret;
1481 : :
1482 : : if (data[IFLA_IPTUN_6RD_PREFIX]) {
1483 : : ret = true;
1484 : : nla_memcpy(&ip6rd->prefix, data[IFLA_IPTUN_6RD_PREFIX],
1485 : : sizeof(struct in6_addr));
1486 : : }
1487 : :
1488 : : if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
1489 : : ret = true;
1490 : : ip6rd->relay_prefix =
1491 : : nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
1492 : : }
1493 : :
1494 : : if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
1495 : : ret = true;
1496 : : ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
1497 : : }
1498 : :
1499 : : if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
1500 : : ret = true;
1501 : : ip6rd->relay_prefixlen =
1502 : : nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
1503 : : }
1504 : :
1505 : : return ret;
1506 : : }
1507 : : #endif
1508 : :
1509 : 0 : static int ipip6_newlink(struct net *src_net, struct net_device *dev,
1510 : : struct nlattr *tb[], struct nlattr *data[])
1511 : : {
1512 : : struct net *net = dev_net(dev);
1513 : : struct ip_tunnel *nt;
1514 : : #ifdef CONFIG_IPV6_SIT_6RD
1515 : : struct ip_tunnel_6rd ip6rd;
1516 : : #endif
1517 : : int err;
1518 : :
1519 : : nt = netdev_priv(dev);
1520 : 0 : ipip6_netlink_parms(data, &nt->parms);
1521 : :
1522 [ # # ]: 0 : if (ipip6_tunnel_locate(net, &nt->parms, 0))
1523 : : return -EEXIST;
1524 : :
1525 : 0 : err = ipip6_tunnel_create(dev);
1526 : : if (err < 0)
1527 : : return err;
1528 : :
1529 : : #ifdef CONFIG_IPV6_SIT_6RD
1530 : : if (ipip6_netlink_6rd_parms(data, &ip6rd))
1531 : : err = ipip6_tunnel_update_6rd(nt, &ip6rd);
1532 : : #endif
1533 : :
1534 : : return err;
1535 : : }
1536 : :
1537 : 0 : static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
1538 : : struct nlattr *data[])
1539 : : {
1540 : : struct ip_tunnel *t = netdev_priv(dev);
1541 : : struct ip_tunnel_parm p;
1542 : 0 : struct net *net = t->net;
1543 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1544 : : #ifdef CONFIG_IPV6_SIT_6RD
1545 : : struct ip_tunnel_6rd ip6rd;
1546 : : #endif
1547 : :
1548 [ # # ]: 0 : if (dev == sitn->fb_tunnel_dev)
1549 : : return -EINVAL;
1550 : :
1551 : 0 : ipip6_netlink_parms(data, &p);
1552 : :
1553 [ # # ][ # # ]: 0 : if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
[ # # ]
1554 [ # # ]: 0 : (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
1555 : : return -EINVAL;
1556 : :
1557 : 0 : t = ipip6_tunnel_locate(net, &p, 0);
1558 : :
1559 [ # # ]: 0 : if (t) {
1560 [ # # ]: 0 : if (t->dev != dev)
1561 : : return -EEXIST;
1562 : : } else
1563 : 0 : t = netdev_priv(dev);
1564 : :
1565 : 0 : ipip6_tunnel_update(t, &p);
1566 : :
1567 : : #ifdef CONFIG_IPV6_SIT_6RD
1568 : : if (ipip6_netlink_6rd_parms(data, &ip6rd))
1569 : : return ipip6_tunnel_update_6rd(t, &ip6rd);
1570 : : #endif
1571 : :
1572 : 0 : return 0;
1573 : : }
1574 : :
1575 : 0 : static size_t ipip6_get_size(const struct net_device *dev)
1576 : : {
1577 : 0 : return
1578 : : /* IFLA_IPTUN_LINK */
1579 : : nla_total_size(4) +
1580 : : /* IFLA_IPTUN_LOCAL */
1581 : : nla_total_size(4) +
1582 : : /* IFLA_IPTUN_REMOTE */
1583 : : nla_total_size(4) +
1584 : : /* IFLA_IPTUN_TTL */
1585 : : nla_total_size(1) +
1586 : : /* IFLA_IPTUN_TOS */
1587 : : nla_total_size(1) +
1588 : : /* IFLA_IPTUN_PMTUDISC */
1589 : : nla_total_size(1) +
1590 : : /* IFLA_IPTUN_FLAGS */
1591 : : nla_total_size(2) +
1592 : : /* IFLA_IPTUN_PROTO */
1593 : : nla_total_size(1) +
1594 : : #ifdef CONFIG_IPV6_SIT_6RD
1595 : : /* IFLA_IPTUN_6RD_PREFIX */
1596 : : nla_total_size(sizeof(struct in6_addr)) +
1597 : : /* IFLA_IPTUN_6RD_RELAY_PREFIX */
1598 : : nla_total_size(4) +
1599 : : /* IFLA_IPTUN_6RD_PREFIXLEN */
1600 : : nla_total_size(2) +
1601 : : /* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
1602 : : nla_total_size(2) +
1603 : : #endif
1604 : : 0;
1605 : : }
1606 : :
1607 : 0 : static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
1608 : : {
1609 : : struct ip_tunnel *tunnel = netdev_priv(dev);
1610 : : struct ip_tunnel_parm *parm = &tunnel->parms;
1611 : :
1612 [ + - + - ]: 1110 : if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1613 [ + - ]: 555 : nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
1614 [ + - ]: 555 : nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
1615 [ + - ]: 555 : nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
1616 [ + - ]: 555 : nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
1617 : 555 : nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
1618 [ + - ]: 555 : !!(parm->iph.frag_off & htons(IP_DF))) ||
1619 [ - + ]: 555 : nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
1620 : 555 : nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags))
1621 : : goto nla_put_failure;
1622 : :
1623 : : #ifdef CONFIG_IPV6_SIT_6RD
1624 : : if (nla_put(skb, IFLA_IPTUN_6RD_PREFIX, sizeof(struct in6_addr),
1625 : : &tunnel->ip6rd.prefix) ||
1626 : : nla_put_be32(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
1627 : : tunnel->ip6rd.relay_prefix) ||
1628 : : nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
1629 : : tunnel->ip6rd.prefixlen) ||
1630 : : nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
1631 : : tunnel->ip6rd.relay_prefixlen))
1632 : : goto nla_put_failure;
1633 : : #endif
1634 : :
1635 : : return 0;
1636 : :
1637 : : nla_put_failure:
1638 : : return -EMSGSIZE;
1639 : : }
1640 : :
1641 : : static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
1642 : : [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
1643 : : [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
1644 : : [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
1645 : : [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
1646 : : [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
1647 : : [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
1648 : : [IFLA_IPTUN_FLAGS] = { .type = NLA_U16 },
1649 : : [IFLA_IPTUN_PROTO] = { .type = NLA_U8 },
1650 : : #ifdef CONFIG_IPV6_SIT_6RD
1651 : : [IFLA_IPTUN_6RD_PREFIX] = { .len = sizeof(struct in6_addr) },
1652 : : [IFLA_IPTUN_6RD_RELAY_PREFIX] = { .type = NLA_U32 },
1653 : : [IFLA_IPTUN_6RD_PREFIXLEN] = { .type = NLA_U16 },
1654 : : [IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
1655 : : #endif
1656 : : };
1657 : :
1658 : 0 : static void ipip6_dellink(struct net_device *dev, struct list_head *head)
1659 : : {
1660 : : struct net *net = dev_net(dev);
1661 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1662 : :
1663 [ # # ]: 0 : if (dev != sitn->fb_tunnel_dev)
1664 : 0 : unregister_netdevice_queue(dev, head);
1665 : 0 : }
1666 : :
1667 : : static struct rtnl_link_ops sit_link_ops __read_mostly = {
1668 : : .kind = "sit",
1669 : : .maxtype = IFLA_IPTUN_MAX,
1670 : : .policy = ipip6_policy,
1671 : : .priv_size = sizeof(struct ip_tunnel),
1672 : : .setup = ipip6_tunnel_setup,
1673 : : .validate = ipip6_validate,
1674 : : .newlink = ipip6_newlink,
1675 : : .changelink = ipip6_changelink,
1676 : : .get_size = ipip6_get_size,
1677 : : .fill_info = ipip6_fill_info,
1678 : : .dellink = ipip6_dellink,
1679 : : };
1680 : :
1681 : : static struct xfrm_tunnel sit_handler __read_mostly = {
1682 : : .handler = ipip6_rcv,
1683 : : .err_handler = ipip6_err,
1684 : : .priority = 1,
1685 : : };
1686 : :
1687 : : static struct xfrm_tunnel ipip_handler __read_mostly = {
1688 : : .handler = ipip_rcv,
1689 : : .err_handler = ipip6_err,
1690 : : .priority = 2,
1691 : : };
1692 : :
1693 : 0 : static void __net_exit sit_destroy_tunnels(struct net *net,
1694 : : struct list_head *head)
1695 : : {
1696 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1697 : : struct net_device *dev, *aux;
1698 : : int prio;
1699 : :
1700 [ # # ]: 0 : for_each_netdev_safe(net, dev, aux)
1701 [ # # ]: 0 : if (dev->rtnl_link_ops == &sit_link_ops)
1702 : 0 : unregister_netdevice_queue(dev, head);
1703 : :
1704 [ # # ]: 0 : for (prio = 1; prio < 4; prio++) {
1705 : : int h;
1706 [ # # ]: 0 : for (h = 0; h < HASH_SIZE; h++) {
1707 : : struct ip_tunnel *t;
1708 : :
1709 : 0 : t = rtnl_dereference(sitn->tunnels[prio][h]);
1710 [ # # ]: 0 : while (t != NULL) {
1711 : : /* If dev is in the same netns, it has already
1712 : : * been added to the list by the previous loop.
1713 : : */
1714 : : if (!net_eq(dev_net(t->dev), net))
1715 : : unregister_netdevice_queue(t->dev,
1716 : : head);
1717 : 0 : t = rtnl_dereference(t->next);
1718 : : }
1719 : : }
1720 : : }
1721 : 0 : }
1722 : :
1723 : 0 : static int __net_init sit_init_net(struct net *net)
1724 : : {
1725 : 0 : struct sit_net *sitn = net_generic(net, sit_net_id);
1726 : : struct ip_tunnel *t;
1727 : : int err;
1728 : :
1729 : 0 : sitn->tunnels[0] = sitn->tunnels_wc;
1730 : 0 : sitn->tunnels[1] = sitn->tunnels_l;
1731 : 0 : sitn->tunnels[2] = sitn->tunnels_r;
1732 : 0 : sitn->tunnels[3] = sitn->tunnels_r_l;
1733 : :
1734 : 0 : sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
1735 : : ipip6_tunnel_setup);
1736 [ # # ]: 0 : if (!sitn->fb_tunnel_dev) {
1737 : : err = -ENOMEM;
1738 : : goto err_alloc_dev;
1739 : : }
1740 : : dev_net_set(sitn->fb_tunnel_dev, net);
1741 : 0 : sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
1742 : : /* FB netdevice is special: we have one, and only one per netns.
1743 : : * Allowing to move it to another netns is clearly unsafe.
1744 : : */
1745 : 0 : sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1746 : :
1747 : 0 : err = ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
1748 [ # # ]: 0 : if (err)
1749 : : goto err_dev_free;
1750 : :
1751 : : ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1752 : :
1753 [ # # ]: 0 : if ((err = register_netdev(sitn->fb_tunnel_dev)))
1754 : : goto err_reg_dev;
1755 : :
1756 : 0 : t = netdev_priv(sitn->fb_tunnel_dev);
1757 : :
1758 : 0 : strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
1759 : 0 : return 0;
1760 : :
1761 : : err_reg_dev:
1762 : 0 : dev_put(sitn->fb_tunnel_dev);
1763 : : err_dev_free:
1764 : 0 : ipip6_dev_free(sitn->fb_tunnel_dev);
1765 : : err_alloc_dev:
1766 : 0 : return err;
1767 : : }
1768 : :
1769 : 0 : static void __net_exit sit_exit_net(struct net *net)
1770 : : {
1771 : 0 : LIST_HEAD(list);
1772 : :
1773 : 0 : rtnl_lock();
1774 : 0 : sit_destroy_tunnels(net, &list);
1775 : 0 : unregister_netdevice_many(&list);
1776 : 0 : rtnl_unlock();
1777 : 0 : }
1778 : :
1779 : : static struct pernet_operations sit_net_ops = {
1780 : : .init = sit_init_net,
1781 : : .exit = sit_exit_net,
1782 : : .id = &sit_net_id,
1783 : : .size = sizeof(struct sit_net),
1784 : : };
1785 : :
1786 : 0 : static void __exit sit_cleanup(void)
1787 : : {
1788 : 0 : rtnl_link_unregister(&sit_link_ops);
1789 : 0 : xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1790 : 0 : xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1791 : :
1792 : 0 : unregister_pernet_device(&sit_net_ops);
1793 : 0 : rcu_barrier(); /* Wait for completion of call_rcu()'s */
1794 : 0 : }
1795 : :
1796 : 0 : static int __init sit_init(void)
1797 : : {
1798 : : int err;
1799 : :
1800 : 0 : pr_info("IPv6 over IPv4 tunneling driver\n");
1801 : :
1802 : 0 : err = register_pernet_device(&sit_net_ops);
1803 [ # # ]: 0 : if (err < 0)
1804 : : return err;
1805 : 0 : err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
1806 [ # # ]: 0 : if (err < 0) {
1807 : 0 : pr_info("%s: can't register ip6ip4\n", __func__);
1808 : 0 : goto xfrm_tunnel_failed;
1809 : : }
1810 : 0 : err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1811 [ # # ]: 0 : if (err < 0) {
1812 : 0 : pr_info("%s: can't register ip4ip4\n", __func__);
1813 : 0 : goto xfrm_tunnel4_failed;
1814 : : }
1815 : 0 : err = rtnl_link_register(&sit_link_ops);
1816 [ # # ]: 0 : if (err < 0)
1817 : : goto rtnl_link_failed;
1818 : :
1819 : : out:
1820 : 0 : return err;
1821 : :
1822 : : rtnl_link_failed:
1823 : 0 : xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1824 : : xfrm_tunnel4_failed:
1825 : 0 : xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1826 : : xfrm_tunnel_failed:
1827 : 0 : unregister_pernet_device(&sit_net_ops);
1828 : 0 : goto out;
1829 : : }
1830 : :
1831 : : module_init(sit_init);
1832 : : module_exit(sit_cleanup);
1833 : : MODULE_LICENSE("GPL");
1834 : : MODULE_ALIAS_NETDEV("sit0");
|
