Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2013 Nicira, Inc.
3 : : *
4 : : * This program is free software; you can redistribute it and/or
5 : : * modify it under the terms of version 2 of the GNU General Public
6 : : * License as published by the Free Software Foundation.
7 : : *
8 : : * This program is distributed in the hope that it will be useful, but
9 : : * WITHOUT ANY WARRANTY; without even the implied warranty of
10 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 : : * General Public License for more details.
12 : : *
13 : : * You should have received a copy of the GNU General Public License
14 : : * along with this program; if not, write to the Free Software
15 : : * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16 : : * 02110-1301, USA
17 : : */
18 : :
19 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 : :
21 : : #include <linux/capability.h>
22 : : #include <linux/module.h>
23 : : #include <linux/types.h>
24 : : #include <linux/kernel.h>
25 : : #include <linux/slab.h>
26 : : #include <linux/uaccess.h>
27 : : #include <linux/skbuff.h>
28 : : #include <linux/netdevice.h>
29 : : #include <linux/in.h>
30 : : #include <linux/tcp.h>
31 : : #include <linux/udp.h>
32 : : #include <linux/if_arp.h>
33 : : #include <linux/mroute.h>
34 : : #include <linux/init.h>
35 : : #include <linux/in6.h>
36 : : #include <linux/inetdevice.h>
37 : : #include <linux/igmp.h>
38 : : #include <linux/netfilter_ipv4.h>
39 : : #include <linux/etherdevice.h>
40 : : #include <linux/if_ether.h>
41 : : #include <linux/if_vlan.h>
42 : : #include <linux/rculist.h>
43 : : #include <linux/err.h>
44 : :
45 : : #include <net/sock.h>
46 : : #include <net/ip.h>
47 : : #include <net/icmp.h>
48 : : #include <net/protocol.h>
49 : : #include <net/ip_tunnels.h>
50 : : #include <net/arp.h>
51 : : #include <net/checksum.h>
52 : : #include <net/dsfield.h>
53 : : #include <net/inet_ecn.h>
54 : : #include <net/xfrm.h>
55 : : #include <net/net_namespace.h>
56 : : #include <net/netns/generic.h>
57 : : #include <net/rtnetlink.h>
58 : :
59 : : #if IS_ENABLED(CONFIG_IPV6)
60 : : #include <net/ipv6.h>
61 : : #include <net/ip6_fib.h>
62 : : #include <net/ip6_route.h>
63 : : #endif
64 : :
65 : : static unsigned int ip_tunnel_hash(__be32 key, __be32 remote)
66 : : {
67 : 0 : return hash_32((__force u32)key ^ (__force u32)remote,
68 : : IP_TNL_HASH_BITS);
69 : : }
70 : :
71 : 0 : static void __tunnel_dst_set(struct ip_tunnel_dst *idst,
72 : : struct dst_entry *dst)
73 : : {
74 : : struct dst_entry *old_dst;
75 : :
76 [ # # ]: 0 : if (dst) {
77 [ # # ]: 0 : if (dst->flags & DST_NOCACHE)
78 : : dst = NULL;
79 : : else
80 : : dst_clone(dst);
81 : : }
82 : 0 : old_dst = xchg((__force struct dst_entry **)&idst->dst, dst);
83 : 0 : dst_release(old_dst);
84 : 0 : }
85 : :
86 : : static void tunnel_dst_set(struct ip_tunnel *t, struct dst_entry *dst)
87 : : {
88 : 0 : __tunnel_dst_set(this_cpu_ptr(t->dst_cache), dst);
89 : : }
90 : :
91 : 0 : static void tunnel_dst_reset(struct ip_tunnel *t)
92 : : {
93 : : tunnel_dst_set(t, NULL);
94 : : }
95 : :
96 : 0 : void ip_tunnel_dst_reset_all(struct ip_tunnel *t)
97 : : {
98 : : int i;
99 : :
100 [ # # ]: 0 : for_each_possible_cpu(i)
101 : 0 : __tunnel_dst_set(per_cpu_ptr(t->dst_cache, i), NULL);
102 : 0 : }
103 : : EXPORT_SYMBOL(ip_tunnel_dst_reset_all);
104 : :
105 : 0 : static struct rtable *tunnel_rtable_get(struct ip_tunnel *t, u32 cookie)
106 : : {
107 : : struct dst_entry *dst;
108 : :
109 : : rcu_read_lock();
110 : 0 : dst = rcu_dereference(this_cpu_ptr(t->dst_cache)->dst);
111 [ # # ]: 0 : if (dst) {
112 [ # # ][ # # ]: 0 : if (dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
113 : : rcu_read_unlock();
114 : : tunnel_dst_reset(t);
115 : 0 : return NULL;
116 : : }
117 : : dst_hold(dst);
118 : : }
119 : : rcu_read_unlock();
120 : 0 : return (struct rtable *)dst;
121 : : }
122 : :
123 : : static bool ip_tunnel_key_match(const struct ip_tunnel_parm *p,
124 : : __be16 flags, __be32 key)
125 : : {
126 [ # # ][ # # ]: 0 : if (p->i_flags & TUNNEL_KEY) {
[ # # ]
127 [ # # ][ # # ]: 0 : if (flags & TUNNEL_KEY)
[ # # ]
128 : 0 : return key == p->i_key;
129 : : else
130 : : /* key expected, none present */
131 : : return false;
132 : : } else
133 : 0 : return !(flags & TUNNEL_KEY);
134 : : }
135 : :
136 : : /* Fallback tunnel: no source, no destination, no key, no options
137 : :
138 : : Tunnel hash table:
139 : : We require exact key match i.e. if a key is present in packet
140 : : it will match only tunnel with the same key; if it is not present,
141 : : it will match only keyless tunnel.
142 : :
143 : : All keysless packets, if not matched configured keyless tunnels
144 : : will match fallback tunnel.
145 : : Given src, dst and key, find appropriate for input tunnel.
146 : : */
147 : 0 : struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
148 : : int link, __be16 flags,
149 : : __be32 remote, __be32 local,
150 : : __be32 key)
151 : : {
152 : : unsigned int hash;
153 : : struct ip_tunnel *t, *cand = NULL;
154 : : struct hlist_head *head;
155 : :
156 : : hash = ip_tunnel_hash(key, remote);
157 : 0 : head = &itn->tunnels[hash];
158 : :
159 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu(t, head, hash_node) {
[ # # ]
160 [ # # ][ # # ]: 0 : if (local != t->parms.iph.saddr ||
161 [ # # ]: 0 : remote != t->parms.iph.daddr ||
162 : 0 : !(t->dev->flags & IFF_UP))
163 : 0 : continue;
164 : :
165 [ # # ]: 0 : if (!ip_tunnel_key_match(&t->parms, flags, key))
166 : 0 : continue;
167 : :
168 [ # # ]: 0 : if (t->parms.link == link)
169 : : return t;
170 : : else
171 : : cand = t;
172 : : }
173 : :
174 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu(t, head, hash_node) {
[ # # ]
175 [ # # ][ # # ]: 0 : if (remote != t->parms.iph.daddr ||
176 : 0 : !(t->dev->flags & IFF_UP))
177 : 0 : continue;
178 : :
179 [ # # ]: 0 : if (!ip_tunnel_key_match(&t->parms, flags, key))
180 : 0 : continue;
181 : :
182 [ # # ]: 0 : if (t->parms.link == link)
183 : : return t;
184 [ # # ]: 0 : else if (!cand)
185 : : cand = t;
186 : : }
187 : :
188 : : hash = ip_tunnel_hash(key, 0);
189 : 0 : head = &itn->tunnels[hash];
190 : :
191 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu(t, head, hash_node) {
[ # # ]
192 [ # # ][ # # ]: 0 : if ((local != t->parms.iph.saddr &&
193 [ # # ]: 0 : (local != t->parms.iph.daddr ||
194 [ # # ]: 0 : !ipv4_is_multicast(local))) ||
195 : 0 : !(t->dev->flags & IFF_UP))
196 : 0 : continue;
197 : :
198 [ # # ]: 0 : if (!ip_tunnel_key_match(&t->parms, flags, key))
199 : 0 : continue;
200 : :
201 [ # # ]: 0 : if (t->parms.link == link)
202 : : return t;
203 [ # # ]: 0 : else if (!cand)
204 : : cand = t;
205 : : }
206 : :
207 [ # # ]: 0 : if (flags & TUNNEL_NO_KEY)
208 : : goto skip_key_lookup;
209 : :
210 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu(t, head, hash_node) {
[ # # ]
211 [ # # ][ # # ]: 0 : if (t->parms.i_key != key ||
212 : 0 : !(t->dev->flags & IFF_UP))
213 : 0 : continue;
214 : :
215 [ # # ]: 0 : if (t->parms.link == link)
216 : : return t;
217 [ # # ]: 0 : else if (!cand)
218 : : cand = t;
219 : : }
220 : :
221 : : skip_key_lookup:
222 [ # # ]: 0 : if (cand)
223 : : return cand;
224 : :
225 [ # # ][ # # ]: 0 : if (itn->fb_tunnel_dev && itn->fb_tunnel_dev->flags & IFF_UP)
226 : 0 : return netdev_priv(itn->fb_tunnel_dev);
227 : :
228 : :
229 : : return NULL;
230 : : }
231 : : EXPORT_SYMBOL_GPL(ip_tunnel_lookup);
232 : :
233 : : static struct hlist_head *ip_bucket(struct ip_tunnel_net *itn,
234 : : struct ip_tunnel_parm *parms)
235 : : {
236 : : unsigned int h;
237 : : __be32 remote;
238 : :
239 [ # # ][ # # ]: 0 : if (parms->iph.daddr && !ipv4_is_multicast(parms->iph.daddr))
[ # # ][ # # ]
240 : : remote = parms->iph.daddr;
241 : : else
242 : : remote = 0;
243 : :
244 : : h = ip_tunnel_hash(parms->i_key, remote);
245 : : return &itn->tunnels[h];
246 : : }
247 : :
248 : 0 : static void ip_tunnel_add(struct ip_tunnel_net *itn, struct ip_tunnel *t)
249 : : {
250 : 0 : struct hlist_head *head = ip_bucket(itn, &t->parms);
251 : :
252 : 0 : hlist_add_head_rcu(&t->hash_node, head);
253 : 0 : }
254 : :
255 : : static void ip_tunnel_del(struct ip_tunnel *t)
256 : : {
257 : : hlist_del_init_rcu(&t->hash_node);
258 : : }
259 : :
260 : 0 : static struct ip_tunnel *ip_tunnel_find(struct ip_tunnel_net *itn,
261 : : struct ip_tunnel_parm *parms,
262 : : int type)
263 : : {
264 : 0 : __be32 remote = parms->iph.daddr;
265 : 0 : __be32 local = parms->iph.saddr;
266 : 0 : __be32 key = parms->i_key;
267 : 0 : int link = parms->link;
268 : : struct ip_tunnel *t = NULL;
269 : 0 : struct hlist_head *head = ip_bucket(itn, parms);
270 : :
271 [ # # ][ # # ]: 0 : hlist_for_each_entry_rcu(t, head, hash_node) {
[ # # ]
272 [ # # ][ # # ]: 0 : if (local == t->parms.iph.saddr &&
273 [ # # ]: 0 : remote == t->parms.iph.daddr &&
274 [ # # ]: 0 : key == t->parms.i_key &&
275 [ # # ]: 0 : link == t->parms.link &&
276 : 0 : type == t->dev->type)
277 : : break;
278 : : }
279 : 0 : return t;
280 : : }
281 : :
282 : 0 : static struct net_device *__ip_tunnel_create(struct net *net,
283 : : const struct rtnl_link_ops *ops,
284 : : struct ip_tunnel_parm *parms)
285 : : {
286 : : int err;
287 : : struct ip_tunnel *tunnel;
288 : : struct net_device *dev;
289 : : char name[IFNAMSIZ];
290 : :
291 [ # # ]: 0 : if (parms->name[0])
292 : 0 : strlcpy(name, parms->name, IFNAMSIZ);
293 : : else {
294 [ # # ]: 0 : if (strlen(ops->kind) > (IFNAMSIZ - 3)) {
295 : : err = -E2BIG;
296 : : goto failed;
297 : : }
298 : 0 : strlcpy(name, ops->kind, IFNAMSIZ);
299 : 0 : strncat(name, "%d", 2);
300 : : }
301 : :
302 [ # # ]: 0 : ASSERT_RTNL();
303 : 0 : dev = alloc_netdev(ops->priv_size, name, ops->setup);
304 [ # # ]: 0 : if (!dev) {
305 : : err = -ENOMEM;
306 : : goto failed;
307 : : }
308 : : dev_net_set(dev, net);
309 : :
310 : 0 : dev->rtnl_link_ops = ops;
311 : :
312 : : tunnel = netdev_priv(dev);
313 : 0 : tunnel->parms = *parms;
314 : 0 : tunnel->net = net;
315 : :
316 : 0 : err = register_netdevice(dev);
317 [ # # ]: 0 : if (err)
318 : : goto failed_free;
319 : :
320 : : return dev;
321 : :
322 : : failed_free:
323 : 0 : free_netdev(dev);
324 : : failed:
325 : 0 : return ERR_PTR(err);
326 : : }
327 : :
328 : : static inline void init_tunnel_flow(struct flowi4 *fl4,
329 : : int proto,
330 : : __be32 daddr, __be32 saddr,
331 : : __be32 key, __u8 tos, int oif)
332 : : {
333 : 0 : memset(fl4, 0, sizeof(*fl4));
334 : 0 : fl4->flowi4_oif = oif;
335 : 0 : fl4->daddr = daddr;
336 : 0 : fl4->saddr = saddr;
337 : 0 : fl4->flowi4_tos = tos;
338 : 0 : fl4->flowi4_proto = proto;
339 : 0 : fl4->fl4_gre_key = key;
340 : : }
341 : :
342 : 0 : static int ip_tunnel_bind_dev(struct net_device *dev)
343 : : {
344 : : struct net_device *tdev = NULL;
345 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
346 : : const struct iphdr *iph;
347 : : int hlen = LL_MAX_HEADER;
348 : : int mtu = ETH_DATA_LEN;
349 : 0 : int t_hlen = tunnel->hlen + sizeof(struct iphdr);
350 : :
351 : : iph = &tunnel->parms.iph;
352 : :
353 : : /* Guess output device to choose reasonable mtu and needed_headroom */
354 [ # # ]: 0 : if (iph->daddr) {
355 : : struct flowi4 fl4;
356 : : struct rtable *rt;
357 : :
358 : 0 : init_tunnel_flow(&fl4, iph->protocol, iph->daddr,
359 : : iph->saddr, tunnel->parms.o_key,
360 : 0 : RT_TOS(iph->tos), tunnel->parms.link);
361 : 0 : rt = ip_route_output_key(tunnel->net, &fl4);
362 : :
363 [ # # ]: 0 : if (!IS_ERR(rt)) {
364 : 0 : tdev = rt->dst.dev;
365 : 0 : tunnel_dst_set(tunnel, &rt->dst);
366 : : ip_rt_put(rt);
367 : : }
368 [ # # ]: 0 : if (dev->type != ARPHRD_ETHER)
369 : 0 : dev->flags |= IFF_POINTOPOINT;
370 : : }
371 : :
372 [ # # ][ # # ]: 0 : if (!tdev && tunnel->parms.link)
373 : 0 : tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
374 : :
375 [ # # ]: 0 : if (tdev) {
376 : 0 : hlen = tdev->hard_header_len + tdev->needed_headroom;
377 : 0 : mtu = tdev->mtu;
378 : : }
379 : 0 : dev->iflink = tunnel->parms.link;
380 : :
381 : 0 : dev->needed_headroom = t_hlen + hlen;
382 : 0 : mtu -= (dev->hard_header_len + t_hlen);
383 : :
384 [ # # ]: 0 : if (mtu < 68)
385 : : mtu = 68;
386 : :
387 : 0 : return mtu;
388 : : }
389 : :
390 : 0 : static struct ip_tunnel *ip_tunnel_create(struct net *net,
391 : : struct ip_tunnel_net *itn,
392 : : struct ip_tunnel_parm *parms)
393 : : {
394 : : struct ip_tunnel *nt, *fbt;
395 : : struct net_device *dev;
396 : :
397 [ # # ]: 0 : BUG_ON(!itn->fb_tunnel_dev);
398 : : fbt = netdev_priv(itn->fb_tunnel_dev);
399 : 0 : dev = __ip_tunnel_create(net, itn->fb_tunnel_dev->rtnl_link_ops, parms);
400 [ # # ]: 0 : if (IS_ERR(dev))
401 : : return NULL;
402 : :
403 : 0 : dev->mtu = ip_tunnel_bind_dev(dev);
404 : :
405 : 0 : nt = netdev_priv(dev);
406 : 0 : ip_tunnel_add(itn, nt);
407 : 0 : return nt;
408 : : }
409 : :
410 : 0 : int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
411 : : const struct tnl_ptk_info *tpi, bool log_ecn_error)
412 : : {
413 : : struct pcpu_sw_netstats *tstats;
414 : : const struct iphdr *iph = ip_hdr(skb);
415 : : int err;
416 : :
417 : : #ifdef CONFIG_NET_IPGRE_BROADCAST
418 : : if (ipv4_is_multicast(iph->daddr)) {
419 : : tunnel->dev->stats.multicast++;
420 : : skb->pkt_type = PACKET_BROADCAST;
421 : : }
422 : : #endif
423 : :
424 [ # # ][ # # ]: 0 : if ((!(tpi->flags&TUNNEL_CSUM) && (tunnel->parms.i_flags&TUNNEL_CSUM)) ||
[ # # ]
425 [ # # ]: 0 : ((tpi->flags&TUNNEL_CSUM) && !(tunnel->parms.i_flags&TUNNEL_CSUM))) {
426 : 0 : tunnel->dev->stats.rx_crc_errors++;
427 : 0 : tunnel->dev->stats.rx_errors++;
428 : 0 : goto drop;
429 : : }
430 : :
431 [ # # ]: 0 : if (tunnel->parms.i_flags&TUNNEL_SEQ) {
432 [ # # ][ # # ]: 0 : if (!(tpi->flags&TUNNEL_SEQ) ||
433 [ # # ][ # # ]: 0 : (tunnel->i_seqno && (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {
434 : 0 : tunnel->dev->stats.rx_fifo_errors++;
435 : 0 : tunnel->dev->stats.rx_errors++;
436 : 0 : goto drop;
437 : : }
438 [ # # ]: 0 : tunnel->i_seqno = ntohl(tpi->seq) + 1;
439 : : }
440 : :
441 : : err = IP_ECN_decapsulate(iph, skb);
442 [ # # ]: 0 : if (unlikely(err)) {
443 [ # # ]: 0 : if (log_ecn_error)
444 [ # # ]: 0 : net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
445 : : &iph->saddr, iph->tos);
446 [ # # ]: 0 : if (err > 1) {
447 : 0 : ++tunnel->dev->stats.rx_frame_errors;
448 : 0 : ++tunnel->dev->stats.rx_errors;
449 : 0 : goto drop;
450 : : }
451 : : }
452 : :
453 : 0 : tstats = this_cpu_ptr(tunnel->dev->tstats);
454 : : u64_stats_update_begin(&tstats->syncp);
455 : 0 : tstats->rx_packets++;
456 : 0 : tstats->rx_bytes += skb->len;
457 : : u64_stats_update_end(&tstats->syncp);
458 : :
459 : 0 : skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));
460 : :
461 [ # # ]: 0 : if (tunnel->dev->type == ARPHRD_ETHER) {
462 : 0 : skb->protocol = eth_type_trans(skb, tunnel->dev);
463 : : skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
464 : : } else {
465 : 0 : skb->dev = tunnel->dev;
466 : : }
467 : :
468 : : gro_cells_receive(&tunnel->gro_cells, skb);
469 : : return 0;
470 : :
471 : : drop:
472 : 0 : kfree_skb(skb);
473 : 0 : return 0;
474 : : }
475 : : EXPORT_SYMBOL_GPL(ip_tunnel_rcv);
476 : :
477 : 0 : static int tnl_update_pmtu(struct net_device *dev, struct sk_buff *skb,
478 : : struct rtable *rt, __be16 df)
479 : : {
480 : : struct ip_tunnel *tunnel = netdev_priv(dev);
481 : 0 : int pkt_size = skb->len - tunnel->hlen - dev->hard_header_len;
482 : : int mtu;
483 : :
484 [ # # ]: 0 : if (df)
485 : 0 : mtu = dst_mtu(&rt->dst) - dev->hard_header_len
486 : 0 : - sizeof(struct iphdr) - tunnel->hlen;
487 : : else
488 [ # # ]: 0 : mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
489 : :
490 [ # # ]: 0 : if (skb_dst(skb))
491 : 0 : skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
492 : :
493 [ # # ]: 0 : if (skb->protocol == htons(ETH_P_IP)) {
494 [ # # ][ # # ]: 0 : if (!skb_is_gso(skb) &&
495 [ # # ]: 0 : (df & htons(IP_DF)) && mtu < pkt_size) {
496 : 0 : memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
497 [ # # ]: 0 : icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
498 : 0 : return -E2BIG;
499 : : }
500 : : }
501 : : #if IS_ENABLED(CONFIG_IPV6)
502 [ # # ]: 0 : else if (skb->protocol == htons(ETH_P_IPV6)) {
503 : : struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
504 : :
505 [ # # # # ]: 0 : if (rt6 && mtu < dst_mtu(skb_dst(skb)) &&
[ # # ]
506 : : mtu >= IPV6_MIN_MTU) {
507 [ # # ][ # # ]: 0 : if ((tunnel->parms.iph.daddr &&
508 [ # # ]: 0 : !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
509 : 0 : rt6->rt6i_dst.plen == 128) {
510 : 0 : rt6->rt6i_flags |= RTF_MODIFIED;
511 : : dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
512 : : }
513 : : }
514 : :
515 [ # # ][ # # ]: 0 : if (!skb_is_gso(skb) && mtu >= IPV6_MIN_MTU &&
516 : 0 : mtu < pkt_size) {
517 : 0 : icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
518 : 0 : return -E2BIG;
519 : : }
520 : : }
521 : : #endif
522 : : return 0;
523 : : }
524 : :
525 : 0 : void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
526 : : const struct iphdr *tnl_params, const u8 protocol)
527 : : {
528 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
529 : : const struct iphdr *inner_iph;
530 : : struct flowi4 fl4;
531 : : u8 tos, ttl;
532 : : __be16 df;
533 : 0 : struct rtable *rt; /* Route to the other host */
534 : : unsigned int max_headroom; /* The extra header space needed */
535 : : __be32 dst;
536 : : int err;
537 : : bool connected = true;
538 : :
539 : : inner_iph = (const struct iphdr *)skb_inner_network_header(skb);
540 : :
541 : 0 : dst = tnl_params->daddr;
542 [ # # ]: 0 : if (dst == 0) {
543 : : /* NBMA tunnel */
544 : :
545 [ # # ]: 0 : if (skb_dst(skb) == NULL) {
546 : 0 : dev->stats.tx_fifo_errors++;
547 : 0 : goto tx_error;
548 : : }
549 : :
550 [ # # ]: 0 : if (skb->protocol == htons(ETH_P_IP)) {
551 : : rt = skb_rtable(skb);
552 : 0 : dst = rt_nexthop(rt, inner_iph->daddr);
553 : : }
554 : : #if IS_ENABLED(CONFIG_IPV6)
555 [ # # ]: 0 : else if (skb->protocol == htons(ETH_P_IPV6)) {
556 : : const struct in6_addr *addr6;
557 : : struct neighbour *neigh;
558 : : bool do_tx_error_icmp;
559 : : int addr_type;
560 : :
561 : : neigh = dst_neigh_lookup(skb_dst(skb),
562 : 0 : &ipv6_hdr(skb)->daddr);
563 [ # # ]: 0 : if (neigh == NULL)
564 : : goto tx_error;
565 : :
566 : 0 : addr6 = (const struct in6_addr *)&neigh->primary_key;
567 : : addr_type = ipv6_addr_type(addr6);
568 : :
569 [ # # ]: 0 : if (addr_type == IPV6_ADDR_ANY) {
570 : 0 : addr6 = &ipv6_hdr(skb)->daddr;
571 : : addr_type = ipv6_addr_type(addr6);
572 : : }
573 : :
574 [ # # ]: 0 : if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
575 : : do_tx_error_icmp = true;
576 : : else {
577 : : do_tx_error_icmp = false;
578 : 0 : dst = addr6->s6_addr32[3];
579 : : }
580 : : neigh_release(neigh);
581 [ # # ]: 0 : if (do_tx_error_icmp)
582 : : goto tx_error_icmp;
583 : : }
584 : : #endif
585 : : else
586 : : goto tx_error;
587 : :
588 : : connected = false;
589 : : }
590 : :
591 : 0 : tos = tnl_params->tos;
592 [ # # ]: 0 : if (tos & 0x1) {
593 : 0 : tos &= ~0x1;
594 [ # # ]: 0 : if (skb->protocol == htons(ETH_P_IP)) {
595 : 0 : tos = inner_iph->tos;
596 : : connected = false;
597 [ # # ]: 0 : } else if (skb->protocol == htons(ETH_P_IPV6)) {
598 : : tos = ipv6_get_dsfield((const struct ipv6hdr *)inner_iph);
599 : : connected = false;
600 : : }
601 : : }
602 : :
603 : 0 : init_tunnel_flow(&fl4, protocol, dst, tnl_params->saddr,
604 : : tunnel->parms.o_key, RT_TOS(tos), tunnel->parms.link);
605 : :
606 [ # # ]: 0 : rt = connected ? tunnel_rtable_get(tunnel, 0) : NULL;
607 : :
608 [ # # ]: 0 : if (!rt) {
609 : 0 : rt = ip_route_output_key(tunnel->net, &fl4);
610 : :
611 [ # # ]: 0 : if (IS_ERR(rt)) {
612 : 0 : dev->stats.tx_carrier_errors++;
613 : 0 : goto tx_error;
614 : : }
615 [ # # ]: 0 : if (connected)
616 : 0 : tunnel_dst_set(tunnel, &rt->dst);
617 : : }
618 : :
619 [ # # ]: 0 : if (rt->dst.dev == dev) {
620 : : ip_rt_put(rt);
621 : 0 : dev->stats.collisions++;
622 : 0 : goto tx_error;
623 : : }
624 : :
625 [ # # ]: 0 : if (tnl_update_pmtu(dev, skb, rt, tnl_params->frag_off)) {
626 : : ip_rt_put(rt);
627 : : goto tx_error;
628 : : }
629 : :
630 [ # # ]: 0 : if (tunnel->err_count > 0) {
631 [ # # ]: 0 : if (time_before(jiffies,
632 : : tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
633 : 0 : tunnel->err_count--;
634 : :
635 : 0 : memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
636 : : dst_link_failure(skb);
637 : : } else
638 : 0 : tunnel->err_count = 0;
639 : : }
640 : :
641 : : tos = ip_tunnel_ecn_encap(tos, inner_iph, skb);
642 : 0 : ttl = tnl_params->ttl;
643 [ # # ]: 0 : if (ttl == 0) {
644 [ # # ]: 0 : if (skb->protocol == htons(ETH_P_IP))
645 : 0 : ttl = inner_iph->ttl;
646 : : #if IS_ENABLED(CONFIG_IPV6)
647 [ # # ]: 0 : else if (skb->protocol == htons(ETH_P_IPV6))
648 : 0 : ttl = ((const struct ipv6hdr *)inner_iph)->hop_limit;
649 : : #endif
650 : : else
651 : 0 : ttl = ip4_dst_hoplimit(&rt->dst);
652 : : }
653 : :
654 : 0 : df = tnl_params->frag_off;
655 [ # # ]: 0 : if (skb->protocol == htons(ETH_P_IP))
656 : 0 : df |= (inner_iph->frag_off&htons(IP_DF));
657 : :
658 : 0 : max_headroom = LL_RESERVED_SPACE(rt->dst.dev) + sizeof(struct iphdr)
659 : 0 : + rt->dst.header_len;
660 [ # # ]: 0 : if (max_headroom > dev->needed_headroom)
661 : 0 : dev->needed_headroom = max_headroom;
662 : :
663 [ # # ]: 0 : if (skb_cow_head(skb, dev->needed_headroom)) {
664 : 0 : dev->stats.tx_dropped++;
665 : 0 : kfree_skb(skb);
666 : 0 : return;
667 : : }
668 : :
669 : 0 : err = iptunnel_xmit(rt, skb, fl4.saddr, fl4.daddr, protocol,
670 : : tos, ttl, df, !net_eq(tunnel->net, dev_net(dev)));
671 : 0 : iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
672 : :
673 : : return;
674 : :
675 : : #if IS_ENABLED(CONFIG_IPV6)
676 : : tx_error_icmp:
677 : : dst_link_failure(skb);
678 : : #endif
679 : : tx_error:
680 : 0 : dev->stats.tx_errors++;
681 : 0 : kfree_skb(skb);
682 : : }
683 : : EXPORT_SYMBOL_GPL(ip_tunnel_xmit);
684 : :
685 : 0 : static void ip_tunnel_update(struct ip_tunnel_net *itn,
686 : : struct ip_tunnel *t,
687 : : struct net_device *dev,
688 : : struct ip_tunnel_parm *p,
689 : : bool set_mtu)
690 : : {
691 : : ip_tunnel_del(t);
692 : 0 : t->parms.iph.saddr = p->iph.saddr;
693 : 0 : t->parms.iph.daddr = p->iph.daddr;
694 : 0 : t->parms.i_key = p->i_key;
695 : 0 : t->parms.o_key = p->o_key;
696 [ # # ]: 0 : if (dev->type != ARPHRD_ETHER) {
697 : 0 : memcpy(dev->dev_addr, &p->iph.saddr, 4);
698 : 0 : memcpy(dev->broadcast, &p->iph.daddr, 4);
699 : : }
700 : 0 : ip_tunnel_add(itn, t);
701 : :
702 : 0 : t->parms.iph.ttl = p->iph.ttl;
703 : 0 : t->parms.iph.tos = p->iph.tos;
704 : 0 : t->parms.iph.frag_off = p->iph.frag_off;
705 : :
706 [ # # ]: 0 : if (t->parms.link != p->link) {
707 : : int mtu;
708 : :
709 : 0 : t->parms.link = p->link;
710 : 0 : mtu = ip_tunnel_bind_dev(dev);
711 [ # # ]: 0 : if (set_mtu)
712 : 0 : dev->mtu = mtu;
713 : : }
714 : 0 : ip_tunnel_dst_reset_all(t);
715 : 0 : netdev_state_change(dev);
716 : 0 : }
717 : :
718 : 0 : int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd)
719 : : {
720 : : int err = 0;
721 : : struct ip_tunnel *t;
722 : : struct net *net = dev_net(dev);
723 : : struct ip_tunnel *tunnel = netdev_priv(dev);
724 : 0 : struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
725 : :
726 [ # # ]: 0 : BUG_ON(!itn->fb_tunnel_dev);
727 [ # # # # ]: 0 : switch (cmd) {
728 : : case SIOCGETTUNNEL:
729 : : t = NULL;
730 [ # # ]: 0 : if (dev == itn->fb_tunnel_dev)
731 : 0 : t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
732 [ # # ]: 0 : if (t == NULL)
733 : 0 : t = netdev_priv(dev);
734 : 0 : memcpy(p, &t->parms, sizeof(*p));
735 : 0 : break;
736 : :
737 : : case SIOCADDTUNNEL:
738 : : case SIOCCHGTUNNEL:
739 : : err = -EPERM;
740 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
741 : : goto done;
742 [ # # ]: 0 : if (p->iph.ttl)
743 : 0 : p->iph.frag_off |= htons(IP_DF);
744 [ # # ]: 0 : if (!(p->i_flags&TUNNEL_KEY))
745 : 0 : p->i_key = 0;
746 [ # # ]: 0 : if (!(p->o_flags&TUNNEL_KEY))
747 : 0 : p->o_key = 0;
748 : :
749 : 0 : t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
750 : :
751 [ # # ]: 0 : if (!t && (cmd == SIOCADDTUNNEL))
752 : 0 : t = ip_tunnel_create(net, itn, p);
753 : :
754 [ # # ][ # # ]: 0 : if (dev != itn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
755 [ # # ]: 0 : if (t != NULL) {
756 [ # # ]: 0 : if (t->dev != dev) {
757 : : err = -EEXIST;
758 : : break;
759 : : }
760 : : } else {
761 : : unsigned int nflags = 0;
762 : :
763 [ # # ]: 0 : if (ipv4_is_multicast(p->iph.daddr))
764 : : nflags = IFF_BROADCAST;
765 [ # # ]: 0 : else if (p->iph.daddr)
766 : : nflags = IFF_POINTOPOINT;
767 : :
768 [ # # ]: 0 : if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
769 : : err = -EINVAL;
770 : : break;
771 : : }
772 : :
773 : 0 : t = netdev_priv(dev);
774 : : }
775 : : }
776 : :
777 [ # # ]: 0 : if (t) {
778 : : err = 0;
779 : 0 : ip_tunnel_update(itn, t, dev, p, true);
780 : : } else
781 [ # # ]: 0 : err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
782 : : break;
783 : :
784 : : case SIOCDELTUNNEL:
785 : : err = -EPERM;
786 [ # # ]: 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
787 : : goto done;
788 : :
789 [ # # ]: 0 : if (dev == itn->fb_tunnel_dev) {
790 : : err = -ENOENT;
791 : 0 : t = ip_tunnel_find(itn, p, itn->fb_tunnel_dev->type);
792 [ # # ]: 0 : if (t == NULL)
793 : : goto done;
794 : : err = -EPERM;
795 [ # # ]: 0 : if (t == netdev_priv(itn->fb_tunnel_dev))
796 : : goto done;
797 : 0 : dev = t->dev;
798 : : }
799 : : unregister_netdevice(dev);
800 : : err = 0;
801 : 0 : break;
802 : :
803 : : default:
804 : : err = -EINVAL;
805 : : }
806 : :
807 : : done:
808 : 0 : return err;
809 : : }
810 : : EXPORT_SYMBOL_GPL(ip_tunnel_ioctl);
811 : :
812 : 0 : int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
813 : : {
814 : : struct ip_tunnel *tunnel = netdev_priv(dev);
815 : 0 : int t_hlen = tunnel->hlen + sizeof(struct iphdr);
816 : :
817 [ # # ][ # # ]: 0 : if (new_mtu < 68 ||
818 : 0 : new_mtu > 0xFFF8 - dev->hard_header_len - t_hlen)
819 : : return -EINVAL;
820 : 0 : dev->mtu = new_mtu;
821 : 0 : return 0;
822 : : }
823 : : EXPORT_SYMBOL_GPL(ip_tunnel_change_mtu);
824 : :
825 : 0 : static void ip_tunnel_dev_free(struct net_device *dev)
826 : : {
827 : : struct ip_tunnel *tunnel = netdev_priv(dev);
828 : :
829 : : gro_cells_destroy(&tunnel->gro_cells);
830 : 0 : free_percpu(tunnel->dst_cache);
831 : 0 : free_percpu(dev->tstats);
832 : 0 : free_netdev(dev);
833 : 0 : }
834 : :
835 : 0 : void ip_tunnel_dellink(struct net_device *dev, struct list_head *head)
836 : : {
837 : : struct ip_tunnel *tunnel = netdev_priv(dev);
838 : : struct ip_tunnel_net *itn;
839 : :
840 : 0 : itn = net_generic(tunnel->net, tunnel->ip_tnl_net_id);
841 : :
842 [ # # ]: 0 : if (itn->fb_tunnel_dev != dev) {
843 : : ip_tunnel_del(netdev_priv(dev));
844 : 0 : unregister_netdevice_queue(dev, head);
845 : : }
846 : 0 : }
847 : : EXPORT_SYMBOL_GPL(ip_tunnel_dellink);
848 : :
849 : 0 : int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
850 : : struct rtnl_link_ops *ops, char *devname)
851 : : {
852 : : struct ip_tunnel_net *itn = net_generic(net, ip_tnl_net_id);
853 : : struct ip_tunnel_parm parms;
854 : : unsigned int i;
855 : :
856 [ # # ]: 0 : for (i = 0; i < IP_TNL_HASH_SIZE; i++)
857 : 0 : INIT_HLIST_HEAD(&itn->tunnels[i]);
858 : :
859 [ # # ]: 0 : if (!ops) {
860 : 0 : itn->fb_tunnel_dev = NULL;
861 : 0 : return 0;
862 : : }
863 : :
864 : 0 : memset(&parms, 0, sizeof(parms));
865 [ # # ]: 0 : if (devname)
866 : 0 : strlcpy(parms.name, devname, IFNAMSIZ);
867 : :
868 : 0 : rtnl_lock();
869 : 0 : itn->fb_tunnel_dev = __ip_tunnel_create(net, ops, &parms);
870 : : /* FB netdevice is special: we have one, and only one per netns.
871 : : * Allowing to move it to another netns is clearly unsafe.
872 : : */
873 [ # # ]: 0 : if (!IS_ERR(itn->fb_tunnel_dev)) {
874 : 0 : itn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
875 : 0 : ip_tunnel_add(itn, netdev_priv(itn->fb_tunnel_dev));
876 : : }
877 : 0 : rtnl_unlock();
878 : :
879 : 0 : return PTR_ERR_OR_ZERO(itn->fb_tunnel_dev);
880 : : }
881 : : EXPORT_SYMBOL_GPL(ip_tunnel_init_net);
882 : :
883 : 0 : static void ip_tunnel_destroy(struct ip_tunnel_net *itn, struct list_head *head,
884 : : struct rtnl_link_ops *ops)
885 : : {
886 : : struct net *net = dev_net(itn->fb_tunnel_dev);
887 : : struct net_device *dev, *aux;
888 : : int h;
889 : :
890 [ # # ]: 0 : for_each_netdev_safe(net, dev, aux)
891 [ # # ]: 0 : if (dev->rtnl_link_ops == ops)
892 : 0 : unregister_netdevice_queue(dev, head);
893 : :
894 [ # # ]: 0 : for (h = 0; h < IP_TNL_HASH_SIZE; h++) {
895 : : struct ip_tunnel *t;
896 : : struct hlist_node *n;
897 : 0 : struct hlist_head *thead = &itn->tunnels[h];
898 : :
899 [ # # ][ # # ]: 0 : hlist_for_each_entry_safe(t, n, thead, hash_node)
[ # # ]
900 : : /* If dev is in the same netns, it has already
901 : : * been added to the list by the previous loop.
902 : : */
903 : : if (!net_eq(dev_net(t->dev), net))
904 : : unregister_netdevice_queue(t->dev, head);
905 : : }
906 : 0 : }
907 : :
908 : 0 : void ip_tunnel_delete_net(struct ip_tunnel_net *itn, struct rtnl_link_ops *ops)
909 : : {
910 : 0 : LIST_HEAD(list);
911 : :
912 : 0 : rtnl_lock();
913 : 0 : ip_tunnel_destroy(itn, &list, ops);
914 : 0 : unregister_netdevice_many(&list);
915 : 0 : rtnl_unlock();
916 : 0 : }
917 : : EXPORT_SYMBOL_GPL(ip_tunnel_delete_net);
918 : :
919 : 0 : int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
920 : : struct ip_tunnel_parm *p)
921 : : {
922 : : struct ip_tunnel *nt;
923 : : struct net *net = dev_net(dev);
924 : : struct ip_tunnel_net *itn;
925 : : int mtu;
926 : : int err;
927 : :
928 : 0 : nt = netdev_priv(dev);
929 : 0 : itn = net_generic(net, nt->ip_tnl_net_id);
930 : :
931 [ # # ]: 0 : if (ip_tunnel_find(itn, p, dev->type))
932 : : return -EEXIST;
933 : :
934 : 0 : nt->net = net;
935 : 0 : nt->parms = *p;
936 : 0 : err = register_netdevice(dev);
937 [ # # ]: 0 : if (err)
938 : : goto out;
939 : :
940 [ # # ][ # # ]: 0 : if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
941 : : eth_hw_addr_random(dev);
942 : :
943 : 0 : mtu = ip_tunnel_bind_dev(dev);
944 [ # # ]: 0 : if (!tb[IFLA_MTU])
945 : 0 : dev->mtu = mtu;
946 : :
947 : 0 : ip_tunnel_add(itn, nt);
948 : :
949 : : out:
950 : 0 : return err;
951 : : }
952 : : EXPORT_SYMBOL_GPL(ip_tunnel_newlink);
953 : :
954 : 0 : int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
955 : : struct ip_tunnel_parm *p)
956 : : {
957 : : struct ip_tunnel *t;
958 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
959 : 0 : struct net *net = tunnel->net;
960 : 0 : struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
961 : :
962 [ # # ]: 0 : if (dev == itn->fb_tunnel_dev)
963 : : return -EINVAL;
964 : :
965 : 0 : t = ip_tunnel_find(itn, p, dev->type);
966 : :
967 [ # # ]: 0 : if (t) {
968 [ # # ]: 0 : if (t->dev != dev)
969 : : return -EEXIST;
970 : : } else {
971 : : t = tunnel;
972 : :
973 [ # # ]: 0 : if (dev->type != ARPHRD_ETHER) {
974 : : unsigned int nflags = 0;
975 : :
976 [ # # ]: 0 : if (ipv4_is_multicast(p->iph.daddr))
977 : : nflags = IFF_BROADCAST;
978 [ # # ]: 0 : else if (p->iph.daddr)
979 : : nflags = IFF_POINTOPOINT;
980 : :
981 [ # # ]: 0 : if ((dev->flags ^ nflags) &
982 : : (IFF_POINTOPOINT | IFF_BROADCAST))
983 : : return -EINVAL;
984 : : }
985 : : }
986 : :
987 : 0 : ip_tunnel_update(itn, t, dev, p, !tb[IFLA_MTU]);
988 : 0 : return 0;
989 : : }
990 : : EXPORT_SYMBOL_GPL(ip_tunnel_changelink);
991 : :
992 : 0 : int ip_tunnel_init(struct net_device *dev)
993 : : {
994 : : struct ip_tunnel *tunnel = netdev_priv(dev);
995 : : struct iphdr *iph = &tunnel->parms.iph;
996 : : int i, err;
997 : :
998 : 0 : dev->destructor = ip_tunnel_dev_free;
999 : 0 : dev->tstats = alloc_percpu(struct pcpu_sw_netstats);
1000 [ # # ]: 0 : if (!dev->tstats)
1001 : : return -ENOMEM;
1002 : :
1003 [ # # ]: 0 : for_each_possible_cpu(i) {
1004 : : struct pcpu_sw_netstats *ipt_stats;
1005 : 0 : ipt_stats = per_cpu_ptr(dev->tstats, i);
1006 : : u64_stats_init(&ipt_stats->syncp);
1007 : : }
1008 : :
1009 : 0 : tunnel->dst_cache = alloc_percpu(struct ip_tunnel_dst);
1010 [ # # ]: 0 : if (!tunnel->dst_cache) {
1011 : 0 : free_percpu(dev->tstats);
1012 : 0 : return -ENOMEM;
1013 : : }
1014 : :
1015 : : err = gro_cells_init(&tunnel->gro_cells, dev);
1016 [ # # ]: 0 : if (err) {
1017 : 0 : free_percpu(tunnel->dst_cache);
1018 : 0 : free_percpu(dev->tstats);
1019 : 0 : return err;
1020 : : }
1021 : :
1022 : 0 : tunnel->dev = dev;
1023 : 0 : tunnel->net = dev_net(dev);
1024 : 0 : strcpy(tunnel->parms.name, dev->name);
1025 : 0 : iph->version = 4;
1026 : 0 : iph->ihl = 5;
1027 : :
1028 : 0 : return 0;
1029 : : }
1030 : : EXPORT_SYMBOL_GPL(ip_tunnel_init);
1031 : :
1032 : 0 : void ip_tunnel_uninit(struct net_device *dev)
1033 : : {
1034 : 0 : struct ip_tunnel *tunnel = netdev_priv(dev);
1035 : 0 : struct net *net = tunnel->net;
1036 : : struct ip_tunnel_net *itn;
1037 : :
1038 : 0 : itn = net_generic(net, tunnel->ip_tnl_net_id);
1039 : : /* fb_tunnel_dev will be unregisted in net-exit call. */
1040 [ # # ]: 0 : if (itn->fb_tunnel_dev != dev)
1041 : : ip_tunnel_del(netdev_priv(dev));
1042 : :
1043 : 0 : ip_tunnel_dst_reset_all(tunnel);
1044 : 0 : }
1045 : : EXPORT_SYMBOL_GPL(ip_tunnel_uninit);
1046 : :
1047 : : /* Do least required initialization, rest of init is done in tunnel_init call */
1048 : 0 : void ip_tunnel_setup(struct net_device *dev, int net_id)
1049 : : {
1050 : : struct ip_tunnel *tunnel = netdev_priv(dev);
1051 : 0 : tunnel->ip_tnl_net_id = net_id;
1052 : 0 : }
1053 : : EXPORT_SYMBOL_GPL(ip_tunnel_setup);
1054 : :
1055 : : MODULE_LICENSE("GPL");
|
