?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: S3C64XX: use timekeeping wrapper on cpuidle
[linux-2.6.git] / net / ipv4 / ip_gre.c
blobb57532d4742c7cccc95a05dd641bfc47875b4717
1 /*
2 * Linux NET3: GRE over IP protocol decoder.
3 *
4 * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15 #include <linux/capability.h>
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/slab.h>
20 #include <asm/uaccess.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
23 #include <linux/in.h>
24 #include <linux/tcp.h>
25 #include <linux/udp.h>
26 #include <linux/if_arp.h>
27 #include <linux/mroute.h>
28 #include <linux/init.h>
29 #include <linux/in6.h>
30 #include <linux/inetdevice.h>
31 #include <linux/igmp.h>
32 #include <linux/netfilter_ipv4.h>
33 #include <linux/etherdevice.h>
34 #include <linux/if_ether.h>
35
36 #include <net/sock.h>
37 #include <net/ip.h>
38 #include <net/icmp.h>
39 #include <net/protocol.h>
40 #include <net/ipip.h>
41 #include <net/arp.h>
42 #include <net/checksum.h>
43 #include <net/dsfield.h>
44 #include <net/inet_ecn.h>
45 #include <net/xfrm.h>
46 #include <net/net_namespace.h>
47 #include <net/netns/generic.h>
48 #include <net/rtnetlink.h>
49 #include <net/gre.h>
50
51 #if IS_ENABLED(CONFIG_IPV6)
52 #include <net/ipv6.h>
53 #include <net/ip6_fib.h>
54 #include <net/ip6_route.h>
55 #endif
56
57 /*
58 Problems & solutions
59 --------------------
60
61 1. The most important issue is detecting local dead loops.
62 They would cause complete host lockup in transmit, which
63 would be "resolved" by stack overflow or, if queueing is enabled,
64 with infinite looping in net_bh.
65
66 We cannot track such dead loops during route installation,
67 it is infeasible task. The most general solutions would be
68 to keep skb->encapsulation counter (sort of local ttl),
69 and silently drop packet when it expires. It is a good
70 solution, but it supposes maintaining new variable in ALL
71 skb, even if no tunneling is used.
72
73 Current solution: xmit_recursion breaks dead loops. This is a percpu
74 counter, since when we enter the first ndo_xmit(), cpu migration is
75 forbidden. We force an exit if this counter reaches RECURSION_LIMIT
76
77 2. Networking dead loops would not kill routers, but would really
78 kill network. IP hop limit plays role of "t->recursion" in this case,
79 if we copy it from packet being encapsulated to upper header.
80 It is very good solution, but it introduces two problems:
81
82 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
83 do not work over tunnels.
84 - traceroute does not work. I planned to relay ICMP from tunnel,
85 so that this problem would be solved and traceroute output
86 would even more informative. This idea appeared to be wrong:
87 only Linux complies to rfc1812 now (yes, guys, Linux is the only
88 true router now :-)), all routers (at least, in neighbourhood of mine)
89 return only 8 bytes of payload. It is the end.
90
91 Hence, if we want that OSPF worked or traceroute said something reasonable,
92 we should search for another solution.
93
94 One of them is to parse packet trying to detect inner encapsulation
95 made by our node. It is difficult or even impossible, especially,
96 taking into account fragmentation. TO be short, ttl is not solution at all.
97
98 Current solution: The solution was UNEXPECTEDLY SIMPLE.
99 We force DF flag on tunnels with preconfigured hop limit,
100 that is ALL. :-) Well, it does not remove the problem completely,
101 but exponential growth of network traffic is changed to linear
102 (branches, that exceed pmtu are pruned) and tunnel mtu
103 rapidly degrades to value <68, where looping stops.
104 Yes, it is not good if there exists a router in the loop,
105 which does not force DF, even when encapsulating packets have DF set.
106 But it is not our problem! Nobody could accuse us, we made
107 all that we could make. Even if it is your gated who injected
108 fatal route to network, even if it were you who configured
109 fatal static route: you are innocent. :-)
110
111
112
113 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
114 practically identical code. It would be good to glue them
115 together, but it is not very evident, how to make them modular.
116 sit is integral part of IPv6, ipip and gre are naturally modular.
117 We could extract common parts (hash table, ioctl etc)
118 to a separate module (ip_tunnel.c).
119
120 Alexey Kuznetsov.
121 */
122
123 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
124 static int ipgre_tunnel_init(struct net_device *dev);
125 static void ipgre_tunnel_setup(struct net_device *dev);
126 static int ipgre_tunnel_bind_dev(struct net_device *dev);
127
128 /* Fallback tunnel: no source, no destination, no key, no options */
129
130 #define HASH_SIZE 16
131
132 static int ipgre_net_id __read_mostly;
133 struct ipgre_net {
134 struct ip_tunnel __rcu *tunnels[4][HASH_SIZE];
135
136 struct net_device *fb_tunnel_dev;
137 };
138
139 /* Tunnel hash table */
140
141 /*
142 4 hash tables:
143
144 3: (remote,local)
145 2: (remote,*)
146 1: (*,local)
147 0: (*,*)
148
149 We require exact key match i.e. if a key is present in packet
150 it will match only tunnel with the same key; if it is not present,
151 it will match only keyless tunnel.
152
153 All keysless packets, if not matched configured keyless tunnels
154 will match fallback tunnel.
155 */
156
157 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
158
159 #define tunnels_r_l tunnels[3]
160 #define tunnels_r tunnels[2]
161 #define tunnels_l tunnels[1]
162 #define tunnels_wc tunnels[0]
163 /*
164 * Locking : hash tables are protected by RCU and RTNL
165 */
166
167 #define for_each_ip_tunnel_rcu(start) \
168 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
169
170 /* often modified stats are per cpu, other are shared (netdev->stats) */
171 struct pcpu_tstats {
172 unsigned long rx_packets;
173 unsigned long rx_bytes;
174 unsigned long tx_packets;
175 unsigned long tx_bytes;
176 } __attribute__((aligned(4*sizeof(unsigned long))));
177
178 static struct net_device_stats *ipgre_get_stats(struct net_device *dev)
179 {
180 struct pcpu_tstats sum = { 0 };
181 int i;
182
183 for_each_possible_cpu(i) {
184 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
185
186 sum.rx_packets += tstats->rx_packets;
187 sum.rx_bytes += tstats->rx_bytes;
188 sum.tx_packets += tstats->tx_packets;
189 sum.tx_bytes += tstats->tx_bytes;
190 }
191 dev->stats.rx_packets = sum.rx_packets;
192 dev->stats.rx_bytes = sum.rx_bytes;
193 dev->stats.tx_packets = sum.tx_packets;
194 dev->stats.tx_bytes = sum.tx_bytes;
195 return &dev->stats;
196 }
197
198 /* Given src, dst and key, find appropriate for input tunnel. */
199
200 static struct ip_tunnel * ipgre_tunnel_lookup(struct net_device *dev,
201 __be32 remote, __be32 local,
202 __be32 key, __be16 gre_proto)
203 {
204 struct net *net = dev_net(dev);
205 int link = dev->ifindex;
206 unsigned int h0 = HASH(remote);
207 unsigned int h1 = HASH(key);
208 struct ip_tunnel *t, *cand = NULL;
209 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
210 int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
211 ARPHRD_ETHER : ARPHRD_IPGRE;
212 int score, cand_score = 4;
213
214 for_each_ip_tunnel_rcu(ign->tunnels_r_l[h0 ^ h1]) {
215 if (local != t->parms.iph.saddr ||
216 remote != t->parms.iph.daddr ||
217 key != t->parms.i_key ||
218 !(t->dev->flags & IFF_UP))
219 continue;
220
221 if (t->dev->type != ARPHRD_IPGRE &&
222 t->dev->type != dev_type)
223 continue;
224
225 score = 0;
226 if (t->parms.link != link)
227 score |= 1;
228 if (t->dev->type != dev_type)
229 score |= 2;
230 if (score == 0)
231 return t;
232
233 if (score < cand_score) {
234 cand = t;
235 cand_score = score;
236 }
237 }
238
239 for_each_ip_tunnel_rcu(ign->tunnels_r[h0 ^ h1]) {
240 if (remote != t->parms.iph.daddr ||
241 key != t->parms.i_key ||
242 !(t->dev->flags & IFF_UP))
243 continue;
244
245 if (t->dev->type != ARPHRD_IPGRE &&
246 t->dev->type != dev_type)
247 continue;
248
249 score = 0;
250 if (t->parms.link != link)
251 score |= 1;
252 if (t->dev->type != dev_type)
253 score |= 2;
254 if (score == 0)
255 return t;
256
257 if (score < cand_score) {
258 cand = t;
259 cand_score = score;
260 }
261 }
262
263 for_each_ip_tunnel_rcu(ign->tunnels_l[h1]) {
264 if ((local != t->parms.iph.saddr &&
265 (local != t->parms.iph.daddr ||
266 !ipv4_is_multicast(local))) ||
267 key != t->parms.i_key ||
268 !(t->dev->flags & IFF_UP))
269 continue;
270
271 if (t->dev->type != ARPHRD_IPGRE &&
272 t->dev->type != dev_type)
273 continue;
274
275 score = 0;
276 if (t->parms.link != link)
277 score |= 1;
278 if (t->dev->type != dev_type)
279 score |= 2;
280 if (score == 0)
281 return t;
282
283 if (score < cand_score) {
284 cand = t;
285 cand_score = score;
286 }
287 }
288
289 for_each_ip_tunnel_rcu(ign->tunnels_wc[h1]) {
290 if (t->parms.i_key != key ||
291 !(t->dev->flags & IFF_UP))
292 continue;
293
294 if (t->dev->type != ARPHRD_IPGRE &&
295 t->dev->type != dev_type)
296 continue;
297
298 score = 0;
299 if (t->parms.link != link)
300 score |= 1;
301 if (t->dev->type != dev_type)
302 score |= 2;
303 if (score == 0)
304 return t;
305
306 if (score < cand_score) {
307 cand = t;
308 cand_score = score;
309 }
310 }
311
312 if (cand != NULL)
313 return cand;
314
315 dev = ign->fb_tunnel_dev;
316 if (dev->flags & IFF_UP)
317 return netdev_priv(dev);
318
319 return NULL;
320 }
321
322 static struct ip_tunnel __rcu **__ipgre_bucket(struct ipgre_net *ign,
323 struct ip_tunnel_parm *parms)
324 {
325 __be32 remote = parms->iph.daddr;
326 __be32 local = parms->iph.saddr;
327 __be32 key = parms->i_key;
328 unsigned int h = HASH(key);
329 int prio = 0;
330
331 if (local)
332 prio |= 1;
333 if (remote && !ipv4_is_multicast(remote)) {
334 prio |= 2;
335 h ^= HASH(remote);
336 }
337
338 return &ign->tunnels[prio][h];
339 }
340
341 static inline struct ip_tunnel __rcu **ipgre_bucket(struct ipgre_net *ign,
342 struct ip_tunnel *t)
343 {
344 return __ipgre_bucket(ign, &t->parms);
345 }
346
347 static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
348 {
349 struct ip_tunnel __rcu **tp = ipgre_bucket(ign, t);
350
351 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
352 rcu_assign_pointer(*tp, t);
353 }
354
355 static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
356 {
357 struct ip_tunnel __rcu **tp;
358 struct ip_tunnel *iter;
359
360 for (tp = ipgre_bucket(ign, t);
361 (iter = rtnl_dereference(*tp)) != NULL;
362 tp = &iter->next) {
363 if (t == iter) {
364 rcu_assign_pointer(*tp, t->next);
365 break;
366 }
367 }
368 }
369
370 static struct ip_tunnel *ipgre_tunnel_find(struct net *net,
371 struct ip_tunnel_parm *parms,
372 int type)
373 {
374 __be32 remote = parms->iph.daddr;
375 __be32 local = parms->iph.saddr;
376 __be32 key = parms->i_key;
377 int link = parms->link;
378 struct ip_tunnel *t;
379 struct ip_tunnel __rcu **tp;
380 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
381
382 for (tp = __ipgre_bucket(ign, parms);
383 (t = rtnl_dereference(*tp)) != NULL;
384 tp = &t->next)
385 if (local == t->parms.iph.saddr &&
386 remote == t->parms.iph.daddr &&
387 key == t->parms.i_key &&
388 link == t->parms.link &&
389 type == t->dev->type)
390 break;
391
392 return t;
393 }
394
395 static struct ip_tunnel *ipgre_tunnel_locate(struct net *net,
396 struct ip_tunnel_parm *parms, int create)
397 {
398 struct ip_tunnel *t, *nt;
399 struct net_device *dev;
400 char name[IFNAMSIZ];
401 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
402
403 t = ipgre_tunnel_find(net, parms, ARPHRD_IPGRE);
404 if (t || !create)
405 return t;
406
407 if (parms->name[0])
408 strlcpy(name, parms->name, IFNAMSIZ);
409 else
410 strcpy(name, "gre%d");
411
412 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
413 if (!dev)
414 return NULL;
415
416 dev_net_set(dev, net);
417
418 nt = netdev_priv(dev);
419 nt->parms = *parms;
420 dev->rtnl_link_ops = &ipgre_link_ops;
421
422 dev->mtu = ipgre_tunnel_bind_dev(dev);
423
424 if (register_netdevice(dev) < 0)
425 goto failed_free;
426
427 /* Can use a lockless transmit, unless we generate output sequences */
428 if (!(nt->parms.o_flags & GRE_SEQ))
429 dev->features |= NETIF_F_LLTX;
430
431 dev_hold(dev);
432 ipgre_tunnel_link(ign, nt);
433 return nt;
434
435 failed_free:
436 free_netdev(dev);
437 return NULL;
438 }
439
440 static void ipgre_tunnel_uninit(struct net_device *dev)
441 {
442 struct net *net = dev_net(dev);
443 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
444
445 ipgre_tunnel_unlink(ign, netdev_priv(dev));
446 dev_put(dev);
447 }
448
449
450 static void ipgre_err(struct sk_buff *skb, u32 info)
451 {
452
453 /* All the routers (except for Linux) return only
454 8 bytes of packet payload. It means, that precise relaying of
455 ICMP in the real Internet is absolutely infeasible.
456
457 Moreover, Cisco "wise men" put GRE key to the third word
458 in GRE header. It makes impossible maintaining even soft state for keyed
459 GRE tunnels with enabled checksum. Tell them "thank you".
460
461 Well, I wonder, rfc1812 was written by Cisco employee,
462 what the hell these idiots break standards established
463 by themselves???
464 */
465
466 const struct iphdr *iph = (const struct iphdr *)skb->data;
467 __be16 *p = (__be16*)(skb->data+(iph->ihl<<2));
468 int grehlen = (iph->ihl<<2) + 4;
469 const int type = icmp_hdr(skb)->type;
470 const int code = icmp_hdr(skb)->code;
471 struct ip_tunnel *t;
472 __be16 flags;
473
474 flags = p[0];
475 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
476 if (flags&(GRE_VERSION|GRE_ROUTING))
477 return;
478 if (flags&GRE_KEY) {
479 grehlen += 4;
480 if (flags&GRE_CSUM)
481 grehlen += 4;
482 }
483 }
484
485 /* If only 8 bytes returned, keyed message will be dropped here */
486 if (skb_headlen(skb) < grehlen)
487 return;
488
489 switch (type) {
490 default:
491 case ICMP_PARAMETERPROB:
492 return;
493
494 case ICMP_DEST_UNREACH:
495 switch (code) {
496 case ICMP_SR_FAILED:
497 case ICMP_PORT_UNREACH:
498 /* Impossible event. */
499 return;
500 case ICMP_FRAG_NEEDED:
501 /* Soft state for pmtu is maintained by IP core. */
502 return;
503 default:
504 /* All others are translated to HOST_UNREACH.
505 rfc2003 contains "deep thoughts" about NET_UNREACH,
506 I believe they are just ether pollution. --ANK
507 */
508 break;
509 }
510 break;
511 case ICMP_TIME_EXCEEDED:
512 if (code != ICMP_EXC_TTL)
513 return;
514 break;
515 }
516
517 rcu_read_lock();
518 t = ipgre_tunnel_lookup(skb->dev, iph->daddr, iph->saddr,
519 flags & GRE_KEY ?
520 *(((__be32 *)p) + (grehlen / 4) - 1) : 0,
521 p[1]);
522 if (t == NULL || t->parms.iph.daddr == 0 ||
523 ipv4_is_multicast(t->parms.iph.daddr))
524 goto out;
525
526 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
527 goto out;
528
529 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
530 t->err_count++;
531 else
532 t->err_count = 1;
533 t->err_time = jiffies;
534 out:
535 rcu_read_unlock();
536 }
537
538 static inline void ipgre_ecn_decapsulate(const struct iphdr *iph, struct sk_buff *skb)
539 {
540 if (INET_ECN_is_ce(iph->tos)) {
541 if (skb->protocol == htons(ETH_P_IP)) {
542 IP_ECN_set_ce(ip_hdr(skb));
543 } else if (skb->protocol == htons(ETH_P_IPV6)) {
544 IP6_ECN_set_ce(ipv6_hdr(skb));
545 }
546 }
547 }
548
549 static inline u8
550 ipgre_ecn_encapsulate(u8 tos, const struct iphdr *old_iph, struct sk_buff *skb)
551 {
552 u8 inner = 0;
553 if (skb->protocol == htons(ETH_P_IP))
554 inner = old_iph->tos;
555 else if (skb->protocol == htons(ETH_P_IPV6))
556 inner = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
557 return INET_ECN_encapsulate(tos, inner);
558 }
559
560 static int ipgre_rcv(struct sk_buff *skb)
561 {
562 const struct iphdr *iph;
563 u8 *h;
564 __be16 flags;
565 __sum16 csum = 0;
566 __be32 key = 0;
567 u32 seqno = 0;
568 struct ip_tunnel *tunnel;
569 int offset = 4;
570 __be16 gre_proto;
571
572 if (!pskb_may_pull(skb, 16))
573 goto drop_nolock;
574
575 iph = ip_hdr(skb);
576 h = skb->data;
577 flags = *(__be16*)h;
578
579 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
580 /* - Version must be 0.
581 - We do not support routing headers.
582 */
583 if (flags&(GRE_VERSION|GRE_ROUTING))
584 goto drop_nolock;
585
586 if (flags&GRE_CSUM) {
587 switch (skb->ip_summed) {
588 case CHECKSUM_COMPLETE:
589 csum = csum_fold(skb->csum);
590 if (!csum)
591 break;
592 /* fall through */
593 case CHECKSUM_NONE:
594 skb->csum = 0;
595 csum = __skb_checksum_complete(skb);
596 skb->ip_summed = CHECKSUM_COMPLETE;
597 }
598 offset += 4;
599 }
600 if (flags&GRE_KEY) {
601 key = *(__be32*)(h + offset);
602 offset += 4;
603 }
604 if (flags&GRE_SEQ) {
605 seqno = ntohl(*(__be32*)(h + offset));
606 offset += 4;
607 }
608 }
609
610 gre_proto = *(__be16 *)(h + 2);
611
612 rcu_read_lock();
613 if ((tunnel = ipgre_tunnel_lookup(skb->dev,
614 iph->saddr, iph->daddr, key,
615 gre_proto))) {
616 struct pcpu_tstats *tstats;
617
618 secpath_reset(skb);
619
620 skb->protocol = gre_proto;
621 /* WCCP version 1 and 2 protocol decoding.
622 * - Change protocol to IP
623 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
624 */
625 if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
626 skb->protocol = htons(ETH_P_IP);
627 if ((*(h + offset) & 0xF0) != 0x40)
628 offset += 4;
629 }
630
631 skb->mac_header = skb->network_header;
632 __pskb_pull(skb, offset);
633 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
634 skb->pkt_type = PACKET_HOST;
635 #ifdef CONFIG_NET_IPGRE_BROADCAST
636 if (ipv4_is_multicast(iph->daddr)) {
637 /* Looped back packet, drop it! */
638 if (rt_is_output_route(skb_rtable(skb)))
639 goto drop;
640 tunnel->dev->stats.multicast++;
641 skb->pkt_type = PACKET_BROADCAST;
642 }
643 #endif
644
645 if (((flags&GRE_CSUM) && csum) ||
646 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
647 tunnel->dev->stats.rx_crc_errors++;
648 tunnel->dev->stats.rx_errors++;
649 goto drop;
650 }
651 if (tunnel->parms.i_flags&GRE_SEQ) {
652 if (!(flags&GRE_SEQ) ||
653 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
654 tunnel->dev->stats.rx_fifo_errors++;
655 tunnel->dev->stats.rx_errors++;
656 goto drop;
657 }
658 tunnel->i_seqno = seqno + 1;
659 }
660
661 /* Warning: All skb pointers will be invalidated! */
662 if (tunnel->dev->type == ARPHRD_ETHER) {
663 if (!pskb_may_pull(skb, ETH_HLEN)) {
664 tunnel->dev->stats.rx_length_errors++;
665 tunnel->dev->stats.rx_errors++;
666 goto drop;
667 }
668
669 iph = ip_hdr(skb);
670 skb->protocol = eth_type_trans(skb, tunnel->dev);
671 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
672 }
673
674 tstats = this_cpu_ptr(tunnel->dev->tstats);
675 tstats->rx_packets++;
676 tstats->rx_bytes += skb->len;
677
678 __skb_tunnel_rx(skb, tunnel->dev);
679
680 skb_reset_network_header(skb);
681 ipgre_ecn_decapsulate(iph, skb);
682
683 netif_rx(skb);
684
685 rcu_read_unlock();
686 return 0;
687 }
688 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
689
690 drop:
691 rcu_read_unlock();
692 drop_nolock:
693 kfree_skb(skb);
694 return 0;
695 }
696
697 static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
698 {
699 struct ip_tunnel *tunnel = netdev_priv(dev);
700 struct pcpu_tstats *tstats;
701 const struct iphdr *old_iph = ip_hdr(skb);
702 const struct iphdr *tiph;
703 struct flowi4 fl4;
704 u8 tos;
705 __be16 df;
706 struct rtable *rt; /* Route to the other host */
707 struct net_device *tdev; /* Device to other host */
708 struct iphdr *iph; /* Our new IP header */
709 unsigned int max_headroom; /* The extra header space needed */
710 int gre_hlen;
711 __be32 dst;
712 int mtu;
713
714 if (dev->type == ARPHRD_ETHER)
715 IPCB(skb)->flags = 0;
716
717 if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
718 gre_hlen = 0;
719 tiph = (const struct iphdr *)skb->data;
720 } else {
721 gre_hlen = tunnel->hlen;
722 tiph = &tunnel->parms.iph;
723 }
724
725 if ((dst = tiph->daddr) == 0) {
726 /* NBMA tunnel */
727
728 if (skb_dst(skb) == NULL) {
729 dev->stats.tx_fifo_errors++;
730 goto tx_error;
731 }
732
733 if (skb->protocol == htons(ETH_P_IP)) {
734 rt = skb_rtable(skb);
735 dst = rt->rt_gateway;
736 }
737 #if IS_ENABLED(CONFIG_IPV6)
738 else if (skb->protocol == htons(ETH_P_IPV6)) {
739 const struct in6_addr *addr6;
740 struct neighbour *neigh;
741 bool do_tx_error_icmp;
742 int addr_type;
743
744 neigh = dst_neigh_lookup(skb_dst(skb), &ipv6_hdr(skb)->daddr);
745 if (neigh == NULL)
746 goto tx_error;
747
748 addr6 = (const struct in6_addr *)&neigh->primary_key;
749 addr_type = ipv6_addr_type(addr6);
750
751 if (addr_type == IPV6_ADDR_ANY) {
752 addr6 = &ipv6_hdr(skb)->daddr;
753 addr_type = ipv6_addr_type(addr6);
754 }
755
756 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
757 do_tx_error_icmp = true;
758 else {
759 do_tx_error_icmp = false;
760 dst = addr6->s6_addr32[3];
761 }
762 neigh_release(neigh);
763 if (do_tx_error_icmp)
764 goto tx_error_icmp;
765 }
766 #endif
767 else
768 goto tx_error;
769 }
770
771 tos = tiph->tos;
772 if (tos == 1) {
773 tos = 0;
774 if (skb->protocol == htons(ETH_P_IP))
775 tos = old_iph->tos;
776 else if (skb->protocol == htons(ETH_P_IPV6))
777 tos = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
778 }
779
780 rt = ip_route_output_gre(dev_net(dev), &fl4, dst, tiph->saddr,
781 tunnel->parms.o_key, RT_TOS(tos),
782 tunnel->parms.link);
783 if (IS_ERR(rt)) {
784 dev->stats.tx_carrier_errors++;
785 goto tx_error;
786 }
787 tdev = rt->dst.dev;
788
789 if (tdev == dev) {
790 ip_rt_put(rt);
791 dev->stats.collisions++;
792 goto tx_error;
793 }
794
795 df = tiph->frag_off;
796 if (df)
797 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - tunnel->hlen;
798 else
799 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
800
801 if (skb_dst(skb))
802 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
803
804 if (skb->protocol == htons(ETH_P_IP)) {
805 df |= (old_iph->frag_off&htons(IP_DF));
806
807 if ((old_iph->frag_off&htons(IP_DF)) &&
808 mtu < ntohs(old_iph->tot_len)) {
809 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
810 ip_rt_put(rt);
811 goto tx_error;
812 }
813 }
814 #if IS_ENABLED(CONFIG_IPV6)
815 else if (skb->protocol == htons(ETH_P_IPV6)) {
816 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
817
818 if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
819 if ((tunnel->parms.iph.daddr &&
820 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
821 rt6->rt6i_dst.plen == 128) {
822 rt6->rt6i_flags |= RTF_MODIFIED;
823 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
824 }
825 }
826
827 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
828 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
829 ip_rt_put(rt);
830 goto tx_error;
831 }
832 }
833 #endif
834
835 if (tunnel->err_count > 0) {
836 if (time_before(jiffies,
837 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
838 tunnel->err_count--;
839
840 dst_link_failure(skb);
841 } else
842 tunnel->err_count = 0;
843 }
844
845 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->dst.header_len;
846
847 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
848 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
849 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
850 if (max_headroom > dev->needed_headroom)
851 dev->needed_headroom = max_headroom;
852 if (!new_skb) {
853 ip_rt_put(rt);
854 dev->stats.tx_dropped++;
855 dev_kfree_skb(skb);
856 return NETDEV_TX_OK;
857 }
858 if (skb->sk)
859 skb_set_owner_w(new_skb, skb->sk);
860 dev_kfree_skb(skb);
861 skb = new_skb;
862 old_iph = ip_hdr(skb);
863 }
864
865 skb_reset_transport_header(skb);
866 skb_push(skb, gre_hlen);
867 skb_reset_network_header(skb);
868 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
869 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
870 IPSKB_REROUTED);
871 skb_dst_drop(skb);
872 skb_dst_set(skb, &rt->dst);
873
874 /*
875 * Push down and install the IPIP header.
876 */
877
878 iph = ip_hdr(skb);
879 iph->version = 4;
880 iph->ihl = sizeof(struct iphdr) >> 2;
881 iph->frag_off = df;
882 iph->protocol = IPPROTO_GRE;
883 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
884 iph->daddr = fl4.daddr;
885 iph->saddr = fl4.saddr;
886
887 if ((iph->ttl = tiph->ttl) == 0) {
888 if (skb->protocol == htons(ETH_P_IP))
889 iph->ttl = old_iph->ttl;
890 #if IS_ENABLED(CONFIG_IPV6)
891 else if (skb->protocol == htons(ETH_P_IPV6))
892 iph->ttl = ((const struct ipv6hdr *)old_iph)->hop_limit;
893 #endif
894 else
895 iph->ttl = ip4_dst_hoplimit(&rt->dst);
896 }
897
898 ((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
899 ((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
900 htons(ETH_P_TEB) : skb->protocol;
901
902 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
903 __be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
904
905 if (tunnel->parms.o_flags&GRE_SEQ) {
906 ++tunnel->o_seqno;
907 *ptr = htonl(tunnel->o_seqno);
908 ptr--;
909 }
910 if (tunnel->parms.o_flags&GRE_KEY) {
911 *ptr = tunnel->parms.o_key;
912 ptr--;
913 }
914 if (tunnel->parms.o_flags&GRE_CSUM) {
915 *ptr = 0;
916 *(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
917 }
918 }
919
920 nf_reset(skb);
921 tstats = this_cpu_ptr(dev->tstats);
922 __IPTUNNEL_XMIT(tstats, &dev->stats);
923 return NETDEV_TX_OK;
924
925 #if IS_ENABLED(CONFIG_IPV6)
926 tx_error_icmp:
927 dst_link_failure(skb);
928 #endif
929 tx_error:
930 dev->stats.tx_errors++;
931 dev_kfree_skb(skb);
932 return NETDEV_TX_OK;
933 }
934
935 static int ipgre_tunnel_bind_dev(struct net_device *dev)
936 {
937 struct net_device *tdev = NULL;
938 struct ip_tunnel *tunnel;
939 const struct iphdr *iph;
940 int hlen = LL_MAX_HEADER;
941 int mtu = ETH_DATA_LEN;
942 int addend = sizeof(struct iphdr) + 4;
943
944 tunnel = netdev_priv(dev);
945 iph = &tunnel->parms.iph;
946
947 /* Guess output device to choose reasonable mtu and needed_headroom */
948
949 if (iph->daddr) {
950 struct flowi4 fl4;
951 struct rtable *rt;
952
953 rt = ip_route_output_gre(dev_net(dev), &fl4,
954 iph->daddr, iph->saddr,
955 tunnel->parms.o_key,
956 RT_TOS(iph->tos),
957 tunnel->parms.link);
958 if (!IS_ERR(rt)) {
959 tdev = rt->dst.dev;
960 ip_rt_put(rt);
961 }
962
963 if (dev->type != ARPHRD_ETHER)
964 dev->flags |= IFF_POINTOPOINT;
965 }
966
967 if (!tdev && tunnel->parms.link)
968 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
969
970 if (tdev) {
971 hlen = tdev->hard_header_len + tdev->needed_headroom;
972 mtu = tdev->mtu;
973 }
974 dev->iflink = tunnel->parms.link;
975
976 /* Precalculate GRE options length */
977 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
978 if (tunnel->parms.o_flags&GRE_CSUM)
979 addend += 4;
980 if (tunnel->parms.o_flags&GRE_KEY)
981 addend += 4;
982 if (tunnel->parms.o_flags&GRE_SEQ)
983 addend += 4;
984 }
985 dev->needed_headroom = addend + hlen;
986 mtu -= dev->hard_header_len + addend;
987
988 if (mtu < 68)
989 mtu = 68;
990
991 tunnel->hlen = addend;
992
993 return mtu;
994 }
995
996 static int
997 ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
998 {
999 int err = 0;
1000 struct ip_tunnel_parm p;
1001 struct ip_tunnel *t;
1002 struct net *net = dev_net(dev);
1003 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1004
1005 switch (cmd) {
1006 case SIOCGETTUNNEL:
1007 t = NULL;
1008 if (dev == ign->fb_tunnel_dev) {
1009 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1010 err = -EFAULT;
1011 break;
1012 }
1013 t = ipgre_tunnel_locate(net, &p, 0);
1014 }
1015 if (t == NULL)
1016 t = netdev_priv(dev);
1017 memcpy(&p, &t->parms, sizeof(p));
1018 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1019 err = -EFAULT;
1020 break;
1021
1022 case SIOCADDTUNNEL:
1023 case SIOCCHGTUNNEL:
1024 err = -EPERM;
1025 if (!capable(CAP_NET_ADMIN))
1026 goto done;
1027
1028 err = -EFAULT;
1029 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1030 goto done;
1031
1032 err = -EINVAL;
1033 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
1034 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
1035 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
1036 goto done;
1037 if (p.iph.ttl)
1038 p.iph.frag_off |= htons(IP_DF);
1039
1040 if (!(p.i_flags&GRE_KEY))
1041 p.i_key = 0;
1042 if (!(p.o_flags&GRE_KEY))
1043 p.o_key = 0;
1044
1045 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1046
1047 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1048 if (t != NULL) {
1049 if (t->dev != dev) {
1050 err = -EEXIST;
1051 break;
1052 }
1053 } else {
1054 unsigned int nflags = 0;
1055
1056 t = netdev_priv(dev);
1057
1058 if (ipv4_is_multicast(p.iph.daddr))
1059 nflags = IFF_BROADCAST;
1060 else if (p.iph.daddr)
1061 nflags = IFF_POINTOPOINT;
1062
1063 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
1064 err = -EINVAL;
1065 break;
1066 }
1067 ipgre_tunnel_unlink(ign, t);
1068 synchronize_net();
1069 t->parms.iph.saddr = p.iph.saddr;
1070 t->parms.iph.daddr = p.iph.daddr;
1071 t->parms.i_key = p.i_key;
1072 t->parms.o_key = p.o_key;
1073 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1074 memcpy(dev->broadcast, &p.iph.daddr, 4);
1075 ipgre_tunnel_link(ign, t);
1076 netdev_state_change(dev);
1077 }
1078 }
1079
1080 if (t) {
1081 err = 0;
1082 if (cmd == SIOCCHGTUNNEL) {
1083 t->parms.iph.ttl = p.iph.ttl;
1084 t->parms.iph.tos = p.iph.tos;
1085 t->parms.iph.frag_off = p.iph.frag_off;
1086 if (t->parms.link != p.link) {
1087 t->parms.link = p.link;
1088 dev->mtu = ipgre_tunnel_bind_dev(dev);
1089 netdev_state_change(dev);
1090 }
1091 }
1092 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1093 err = -EFAULT;
1094 } else
1095 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1096 break;
1097
1098 case SIOCDELTUNNEL:
1099 err = -EPERM;
1100 if (!capable(CAP_NET_ADMIN))
1101 goto done;
1102
1103 if (dev == ign->fb_tunnel_dev) {
1104 err = -EFAULT;
1105 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1106 goto done;
1107 err = -ENOENT;
1108 if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
1109 goto done;
1110 err = -EPERM;
1111 if (t == netdev_priv(ign->fb_tunnel_dev))
1112 goto done;
1113 dev = t->dev;
1114 }
1115 unregister_netdevice(dev);
1116 err = 0;
1117 break;
1118
1119 default:
1120 err = -EINVAL;
1121 }
1122
1123 done:
1124 return err;
1125 }
1126
1127 static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1128 {
1129 struct ip_tunnel *tunnel = netdev_priv(dev);
1130 if (new_mtu < 68 ||
1131 new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
1132 return -EINVAL;
1133 dev->mtu = new_mtu;
1134 return 0;
1135 }
1136
1137 /* Nice toy. Unfortunately, useless in real life :-)
1138 It allows to construct virtual multiprotocol broadcast "LAN"
1139 over the Internet, provided multicast routing is tuned.
1140
1141
1142 I have no idea was this bicycle invented before me,
1143 so that I had to set ARPHRD_IPGRE to a random value.
1144 I have an impression, that Cisco could make something similar,
1145 but this feature is apparently missing in IOS<=11.2(8).
1146
1147 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1148 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1149
1150 ping -t 255 224.66.66.66
1151
1152 If nobody answers, mbone does not work.
1153
1154 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1155 ip addr add 10.66.66.<somewhat>/24 dev Universe
1156 ifconfig Universe up
1157 ifconfig Universe add fe80::<Your_real_addr>/10
1158 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1159 ftp 10.66.66.66
1160 ...
1161 ftp fec0:6666:6666::193.233.7.65
1162 ...
1163
1164 */
1165
1166 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1167 unsigned short type,
1168 const void *daddr, const void *saddr, unsigned int len)
1169 {
1170 struct ip_tunnel *t = netdev_priv(dev);
1171 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1172 __be16 *p = (__be16*)(iph+1);
1173
1174 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1175 p[0] = t->parms.o_flags;
1176 p[1] = htons(type);
1177
1178 /*
1179 * Set the source hardware address.
1180 */
1181
1182 if (saddr)
1183 memcpy(&iph->saddr, saddr, 4);
1184 if (daddr)
1185 memcpy(&iph->daddr, daddr, 4);
1186 if (iph->daddr)
1187 return t->hlen;
1188
1189 return -t->hlen;
1190 }
1191
1192 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1193 {
1194 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
1195 memcpy(haddr, &iph->saddr, 4);
1196 return 4;
1197 }
1198
1199 static const struct header_ops ipgre_header_ops = {
1200 .create = ipgre_header,
1201 .parse = ipgre_header_parse,
1202 };
1203
1204 #ifdef CONFIG_NET_IPGRE_BROADCAST
1205 static int ipgre_open(struct net_device *dev)
1206 {
1207 struct ip_tunnel *t = netdev_priv(dev);
1208
1209 if (ipv4_is_multicast(t->parms.iph.daddr)) {
1210 struct flowi4 fl4;
1211 struct rtable *rt;
1212
1213 rt = ip_route_output_gre(dev_net(dev), &fl4,
1214 t->parms.iph.daddr,
1215 t->parms.iph.saddr,
1216 t->parms.o_key,
1217 RT_TOS(t->parms.iph.tos),
1218 t->parms.link);
1219 if (IS_ERR(rt))
1220 return -EADDRNOTAVAIL;
1221 dev = rt->dst.dev;
1222 ip_rt_put(rt);
1223 if (__in_dev_get_rtnl(dev) == NULL)
1224 return -EADDRNOTAVAIL;
1225 t->mlink = dev->ifindex;
1226 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
1227 }
1228 return 0;
1229 }
1230
1231 static int ipgre_close(struct net_device *dev)
1232 {
1233 struct ip_tunnel *t = netdev_priv(dev);
1234
1235 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
1236 struct in_device *in_dev;
1237 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
1238 if (in_dev)
1239 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1240 }
1241 return 0;
1242 }
1243
1244 #endif
1245
1246 static const struct net_device_ops ipgre_netdev_ops = {
1247 .ndo_init = ipgre_tunnel_init,
1248 .ndo_uninit = ipgre_tunnel_uninit,
1249 #ifdef CONFIG_NET_IPGRE_BROADCAST
1250 .ndo_open = ipgre_open,
1251 .ndo_stop = ipgre_close,
1252 #endif
1253 .ndo_start_xmit = ipgre_tunnel_xmit,
1254 .ndo_do_ioctl = ipgre_tunnel_ioctl,
1255 .ndo_change_mtu = ipgre_tunnel_change_mtu,
1256 .ndo_get_stats = ipgre_get_stats,
1257 };
1258
1259 static void ipgre_dev_free(struct net_device *dev)
1260 {
1261 free_percpu(dev->tstats);
1262 free_netdev(dev);
1263 }
1264
1265 static void ipgre_tunnel_setup(struct net_device *dev)
1266 {
1267 dev->netdev_ops = &ipgre_netdev_ops;
1268 dev->destructor = ipgre_dev_free;
1269
1270 dev->type = ARPHRD_IPGRE;
1271 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1272 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
1273 dev->flags = IFF_NOARP;
1274 dev->iflink = 0;
1275 dev->addr_len = 4;
1276 dev->features |= NETIF_F_NETNS_LOCAL;
1277 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1278 }
1279
1280 static int ipgre_tunnel_init(struct net_device *dev)
1281 {
1282 struct ip_tunnel *tunnel;
1283 struct iphdr *iph;
1284
1285 tunnel = netdev_priv(dev);
1286 iph = &tunnel->parms.iph;
1287
1288 tunnel->dev = dev;
1289 strcpy(tunnel->parms.name, dev->name);
1290
1291 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1292 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1293
1294 if (iph->daddr) {
1295 #ifdef CONFIG_NET_IPGRE_BROADCAST
1296 if (ipv4_is_multicast(iph->daddr)) {
1297 if (!iph->saddr)
1298 return -EINVAL;
1299 dev->flags = IFF_BROADCAST;
1300 dev->header_ops = &ipgre_header_ops;
1301 }
1302 #endif
1303 } else
1304 dev->header_ops = &ipgre_header_ops;
1305
1306 dev->tstats = alloc_percpu(struct pcpu_tstats);
1307 if (!dev->tstats)
1308 return -ENOMEM;
1309
1310 return 0;
1311 }
1312
1313 static void ipgre_fb_tunnel_init(struct net_device *dev)
1314 {
1315 struct ip_tunnel *tunnel = netdev_priv(dev);
1316 struct iphdr *iph = &tunnel->parms.iph;
1317
1318 tunnel->dev = dev;
1319 strcpy(tunnel->parms.name, dev->name);
1320
1321 iph->version = 4;
1322 iph->protocol = IPPROTO_GRE;
1323 iph->ihl = 5;
1324 tunnel->hlen = sizeof(struct iphdr) + 4;
1325
1326 dev_hold(dev);
1327 }
1328
1329
1330 static const struct gre_protocol ipgre_protocol = {
1331 .handler = ipgre_rcv,
1332 .err_handler = ipgre_err,
1333 };
1334
1335 static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
1336 {
1337 int prio;
1338
1339 for (prio = 0; prio < 4; prio++) {
1340 int h;
1341 for (h = 0; h < HASH_SIZE; h++) {
1342 struct ip_tunnel *t;
1343
1344 t = rtnl_dereference(ign->tunnels[prio][h]);
1345
1346 while (t != NULL) {
1347 unregister_netdevice_queue(t->dev, head);
1348 t = rtnl_dereference(t->next);
1349 }
1350 }
1351 }
1352 }
1353
1354 static int __net_init ipgre_init_net(struct net *net)
1355 {
1356 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1357 int err;
1358
1359 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1360 ipgre_tunnel_setup);
1361 if (!ign->fb_tunnel_dev) {
1362 err = -ENOMEM;
1363 goto err_alloc_dev;
1364 }
1365 dev_net_set(ign->fb_tunnel_dev, net);
1366
1367 ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
1368 ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
1369
1370 if ((err = register_netdev(ign->fb_tunnel_dev)))
1371 goto err_reg_dev;
1372
1373 rcu_assign_pointer(ign->tunnels_wc[0],
1374 netdev_priv(ign->fb_tunnel_dev));
1375 return 0;
1376
1377 err_reg_dev:
1378 ipgre_dev_free(ign->fb_tunnel_dev);
1379 err_alloc_dev:
1380 return err;
1381 }
1382
1383 static void __net_exit ipgre_exit_net(struct net *net)
1384 {
1385 struct ipgre_net *ign;
1386 LIST_HEAD(list);
1387
1388 ign = net_generic(net, ipgre_net_id);
1389 rtnl_lock();
1390 ipgre_destroy_tunnels(ign, &list);
1391 unregister_netdevice_many(&list);
1392 rtnl_unlock();
1393 }
1394
1395 static struct pernet_operations ipgre_net_ops = {
1396 .init = ipgre_init_net,
1397 .exit = ipgre_exit_net,
1398 .id = &ipgre_net_id,
1399 .size = sizeof(struct ipgre_net),
1400 };
1401
1402 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
1403 {
1404 __be16 flags;
1405
1406 if (!data)
1407 return 0;
1408
1409 flags = 0;
1410 if (data[IFLA_GRE_IFLAGS])
1411 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1412 if (data[IFLA_GRE_OFLAGS])
1413 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1414 if (flags & (GRE_VERSION|GRE_ROUTING))
1415 return -EINVAL;
1416
1417 return 0;
1418 }
1419
1420 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1421 {
1422 __be32 daddr;
1423
1424 if (tb[IFLA_ADDRESS]) {
1425 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1426 return -EINVAL;
1427 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1428 return -EADDRNOTAVAIL;
1429 }
1430
1431 if (!data)
1432 goto out;
1433
1434 if (data[IFLA_GRE_REMOTE]) {
1435 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1436 if (!daddr)
1437 return -EINVAL;
1438 }
1439
1440 out:
1441 return ipgre_tunnel_validate(tb, data);
1442 }
1443
1444 static void ipgre_netlink_parms(struct nlattr *data[],
1445 struct ip_tunnel_parm *parms)
1446 {
1447 memset(parms, 0, sizeof(*parms));
1448
1449 parms->iph.protocol = IPPROTO_GRE;
1450
1451 if (!data)
1452 return;
1453
1454 if (data[IFLA_GRE_LINK])
1455 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1456
1457 if (data[IFLA_GRE_IFLAGS])
1458 parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);
1459
1460 if (data[IFLA_GRE_OFLAGS])
1461 parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);
1462
1463 if (data[IFLA_GRE_IKEY])
1464 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1465
1466 if (data[IFLA_GRE_OKEY])
1467 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1468
1469 if (data[IFLA_GRE_LOCAL])
1470 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
1471
1472 if (data[IFLA_GRE_REMOTE])
1473 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
1474
1475 if (data[IFLA_GRE_TTL])
1476 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1477
1478 if (data[IFLA_GRE_TOS])
1479 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1480
1481 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
1482 parms->iph.frag_off = htons(IP_DF);
1483 }
1484
1485 static int ipgre_tap_init(struct net_device *dev)
1486 {
1487 struct ip_tunnel *tunnel;
1488
1489 tunnel = netdev_priv(dev);
1490
1491 tunnel->dev = dev;
1492 strcpy(tunnel->parms.name, dev->name);
1493
1494 ipgre_tunnel_bind_dev(dev);
1495
1496 dev->tstats = alloc_percpu(struct pcpu_tstats);
1497 if (!dev->tstats)
1498 return -ENOMEM;
1499
1500 return 0;
1501 }
1502
1503 static const struct net_device_ops ipgre_tap_netdev_ops = {
1504 .ndo_init = ipgre_tap_init,
1505 .ndo_uninit = ipgre_tunnel_uninit,
1506 .ndo_start_xmit = ipgre_tunnel_xmit,
1507 .ndo_set_mac_address = eth_mac_addr,
1508 .ndo_validate_addr = eth_validate_addr,
1509 .ndo_change_mtu = ipgre_tunnel_change_mtu,
1510 .ndo_get_stats = ipgre_get_stats,
1511 };
1512
1513 static void ipgre_tap_setup(struct net_device *dev)
1514 {
1515
1516 ether_setup(dev);
1517
1518 dev->netdev_ops = &ipgre_tap_netdev_ops;
1519 dev->destructor = ipgre_dev_free;
1520
1521 dev->iflink = 0;
1522 dev->features |= NETIF_F_NETNS_LOCAL;
1523 }
1524
1525 static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
1526 struct nlattr *data[])
1527 {
1528 struct ip_tunnel *nt;
1529 struct net *net = dev_net(dev);
1530 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1531 int mtu;
1532 int err;
1533
1534 nt = netdev_priv(dev);
1535 ipgre_netlink_parms(data, &nt->parms);
1536
1537 if (ipgre_tunnel_find(net, &nt->parms, dev->type))
1538 return -EEXIST;
1539
1540 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
1541 eth_hw_addr_random(dev);
1542
1543 mtu = ipgre_tunnel_bind_dev(dev);
1544 if (!tb[IFLA_MTU])
1545 dev->mtu = mtu;
1546
1547 /* Can use a lockless transmit, unless we generate output sequences */
1548 if (!(nt->parms.o_flags & GRE_SEQ))
1549 dev->features |= NETIF_F_LLTX;
1550
1551 err = register_netdevice(dev);
1552 if (err)
1553 goto out;
1554
1555 dev_hold(dev);
1556 ipgre_tunnel_link(ign, nt);
1557
1558 out:
1559 return err;
1560 }
1561
1562 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1563 struct nlattr *data[])
1564 {
1565 struct ip_tunnel *t, *nt;
1566 struct net *net = dev_net(dev);
1567 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1568 struct ip_tunnel_parm p;
1569 int mtu;
1570
1571 if (dev == ign->fb_tunnel_dev)
1572 return -EINVAL;
1573
1574 nt = netdev_priv(dev);
1575 ipgre_netlink_parms(data, &p);
1576
1577 t = ipgre_tunnel_locate(net, &p, 0);
1578
1579 if (t) {
1580 if (t->dev != dev)
1581 return -EEXIST;
1582 } else {
1583 t = nt;
1584
1585 if (dev->type != ARPHRD_ETHER) {
1586 unsigned int nflags = 0;
1587
1588 if (ipv4_is_multicast(p.iph.daddr))
1589 nflags = IFF_BROADCAST;
1590 else if (p.iph.daddr)
1591 nflags = IFF_POINTOPOINT;
1592
1593 if ((dev->flags ^ nflags) &
1594 (IFF_POINTOPOINT | IFF_BROADCAST))
1595 return -EINVAL;
1596 }
1597
1598 ipgre_tunnel_unlink(ign, t);
1599 t->parms.iph.saddr = p.iph.saddr;
1600 t->parms.iph.daddr = p.iph.daddr;
1601 t->parms.i_key = p.i_key;
1602 if (dev->type != ARPHRD_ETHER) {
1603 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1604 memcpy(dev->broadcast, &p.iph.daddr, 4);
1605 }
1606 ipgre_tunnel_link(ign, t);
1607 netdev_state_change(dev);
1608 }
1609
1610 t->parms.o_key = p.o_key;
1611 t->parms.iph.ttl = p.iph.ttl;
1612 t->parms.iph.tos = p.iph.tos;
1613 t->parms.iph.frag_off = p.iph.frag_off;
1614
1615 if (t->parms.link != p.link) {
1616 t->parms.link = p.link;
1617 mtu = ipgre_tunnel_bind_dev(dev);
1618 if (!tb[IFLA_MTU])
1619 dev->mtu = mtu;
1620 netdev_state_change(dev);
1621 }
1622
1623 return 0;
1624 }
1625
1626 static size_t ipgre_get_size(const struct net_device *dev)
1627 {
1628 return
1629 /* IFLA_GRE_LINK */
1630 nla_total_size(4) +
1631 /* IFLA_GRE_IFLAGS */
1632 nla_total_size(2) +
1633 /* IFLA_GRE_OFLAGS */
1634 nla_total_size(2) +
1635 /* IFLA_GRE_IKEY */
1636 nla_total_size(4) +
1637 /* IFLA_GRE_OKEY */
1638 nla_total_size(4) +
1639 /* IFLA_GRE_LOCAL */
1640 nla_total_size(4) +
1641 /* IFLA_GRE_REMOTE */
1642 nla_total_size(4) +
1643 /* IFLA_GRE_TTL */
1644 nla_total_size(1) +
1645 /* IFLA_GRE_TOS */
1646 nla_total_size(1) +
1647 /* IFLA_GRE_PMTUDISC */
1648 nla_total_size(1) +
1649 0;
1650 }
1651
1652 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1653 {
1654 struct ip_tunnel *t = netdev_priv(dev);
1655 struct ip_tunnel_parm *p = &t->parms;
1656
1657 NLA_PUT_U32(skb, IFLA_GRE_LINK, p->link);
1658 NLA_PUT_BE16(skb, IFLA_GRE_IFLAGS, p->i_flags);
1659 NLA_PUT_BE16(skb, IFLA_GRE_OFLAGS, p->o_flags);
1660 NLA_PUT_BE32(skb, IFLA_GRE_IKEY, p->i_key);
1661 NLA_PUT_BE32(skb, IFLA_GRE_OKEY, p->o_key);
1662 NLA_PUT_BE32(skb, IFLA_GRE_LOCAL, p->iph.saddr);
1663 NLA_PUT_BE32(skb, IFLA_GRE_REMOTE, p->iph.daddr);
1664 NLA_PUT_U8(skb, IFLA_GRE_TTL, p->iph.ttl);
1665 NLA_PUT_U8(skb, IFLA_GRE_TOS, p->iph.tos);
1666 NLA_PUT_U8(skb, IFLA_GRE_PMTUDISC, !!(p->iph.frag_off & htons(IP_DF)));
1667
1668 return 0;
1669
1670 nla_put_failure:
1671 return -EMSGSIZE;
1672 }
1673
1674 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1675 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1676 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1677 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1678 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1679 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
1680 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1681 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
1682 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1683 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1684 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
1685 };
1686
1687 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1688 .kind = "gre",
1689 .maxtype = IFLA_GRE_MAX,
1690 .policy = ipgre_policy,
1691 .priv_size = sizeof(struct ip_tunnel),
1692 .setup = ipgre_tunnel_setup,
1693 .validate = ipgre_tunnel_validate,
1694 .newlink = ipgre_newlink,
1695 .changelink = ipgre_changelink,
1696 .get_size = ipgre_get_size,
1697 .fill_info = ipgre_fill_info,
1698 };
1699
1700 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1701 .kind = "gretap",
1702 .maxtype = IFLA_GRE_MAX,
1703 .policy = ipgre_policy,
1704 .priv_size = sizeof(struct ip_tunnel),
1705 .setup = ipgre_tap_setup,
1706 .validate = ipgre_tap_validate,
1707 .newlink = ipgre_newlink,
1708 .changelink = ipgre_changelink,
1709 .get_size = ipgre_get_size,
1710 .fill_info = ipgre_fill_info,
1711 };
1712
1713 /*
1714 * And now the modules code and kernel interface.
1715 */
1716
1717 static int __init ipgre_init(void)
1718 {
1719 int err;
1720
1721 pr_info("GRE over IPv4 tunneling driver\n");
1722
1723 err = register_pernet_device(&ipgre_net_ops);
1724 if (err < 0)
1725 return err;
1726
1727 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1728 if (err < 0) {
1729 pr_info("%s: can't add protocol\n", __func__);
1730 goto add_proto_failed;
1731 }
1732
1733 err = rtnl_link_register(&ipgre_link_ops);
1734 if (err < 0)
1735 goto rtnl_link_failed;
1736
1737 err = rtnl_link_register(&ipgre_tap_ops);
1738 if (err < 0)
1739 goto tap_ops_failed;
1740
1741 out:
1742 return err;
1743
1744 tap_ops_failed:
1745 rtnl_link_unregister(&ipgre_link_ops);
1746 rtnl_link_failed:
1747 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1748 add_proto_failed:
1749 unregister_pernet_device(&ipgre_net_ops);
1750 goto out;
1751 }
1752
1753 static void __exit ipgre_fini(void)
1754 {
1755 rtnl_link_unregister(&ipgre_tap_ops);
1756 rtnl_link_unregister(&ipgre_link_ops);
1757 if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
1758 pr_info("%s: can't remove protocol\n", __func__);
1759 unregister_pernet_device(&ipgre_net_ops);
1760 }
1761
1762 module_init(ipgre_init);
1763 module_exit(ipgre_fini);
1764 MODULE_LICENSE("GPL");
1765 MODULE_ALIAS_RTNL_LINK("gre");
1766 MODULE_ALIAS_RTNL_LINK("gretap");
1767 MODULE_ALIAS_NETDEV("gre0");
Linus' kernel tree