?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-3.11' of git://linux-nfs.org/~bfields/linux
[linux-2.6.git] / net / ipv4 / ip_gre.c
blob1f6eab66f7cee5f94e1a5cfd6b6ea919184b5d35
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/ip_tunnels.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 Alexey Kuznetsov.
112 */
113
114 static bool log_ecn_error = true;
115 module_param(log_ecn_error, bool, 0644);
116 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
117
118 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
119 static int ipgre_tunnel_init(struct net_device *dev);
120
121 static int ipgre_net_id __read_mostly;
122 static int gre_tap_net_id __read_mostly;
123
124 static int ipgre_err(struct sk_buff *skb, u32 info,
125 const struct tnl_ptk_info *tpi)
126 {
127
128 /* All the routers (except for Linux) return only
129 8 bytes of packet payload. It means, that precise relaying of
130 ICMP in the real Internet is absolutely infeasible.
131
132 Moreover, Cisco "wise men" put GRE key to the third word
133 in GRE header. It makes impossible maintaining even soft
134 state for keyed GRE tunnels with enabled checksum. Tell
135 them "thank you".
136
137 Well, I wonder, rfc1812 was written by Cisco employee,
138 what the hell these idiots break standards established
139 by themselves???
140 */
141 struct net *net = dev_net(skb->dev);
142 struct ip_tunnel_net *itn;
143 const struct iphdr *iph;
144 const int type = icmp_hdr(skb)->type;
145 const int code = icmp_hdr(skb)->code;
146 struct ip_tunnel *t;
147
148 switch (type) {
149 default:
150 case ICMP_PARAMETERPROB:
151 return PACKET_RCVD;
152
153 case ICMP_DEST_UNREACH:
154 switch (code) {
155 case ICMP_SR_FAILED:
156 case ICMP_PORT_UNREACH:
157 /* Impossible event. */
158 return PACKET_RCVD;
159 default:
160 /* All others are translated to HOST_UNREACH.
161 rfc2003 contains "deep thoughts" about NET_UNREACH,
162 I believe they are just ether pollution. --ANK
163 */
164 break;
165 }
166 break;
167 case ICMP_TIME_EXCEEDED:
168 if (code != ICMP_EXC_TTL)
169 return PACKET_RCVD;
170 break;
171
172 case ICMP_REDIRECT:
173 break;
174 }
175
176 if (tpi->proto == htons(ETH_P_TEB))
177 itn = net_generic(net, gre_tap_net_id);
178 else
179 itn = net_generic(net, ipgre_net_id);
180
181 iph = (const struct iphdr *)skb->data;
182 t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
183 iph->daddr, iph->saddr, tpi->key);
184
185 if (t == NULL)
186 return PACKET_REJECT;
187
188 if (t->parms.iph.daddr == 0 ||
189 ipv4_is_multicast(t->parms.iph.daddr))
190 return PACKET_RCVD;
191
192 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
193 return PACKET_RCVD;
194
195 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
196 t->err_count++;
197 else
198 t->err_count = 1;
199 t->err_time = jiffies;
200 return PACKET_RCVD;
201 }
202
203 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
204 {
205 struct net *net = dev_net(skb->dev);
206 struct ip_tunnel_net *itn;
207 const struct iphdr *iph;
208 struct ip_tunnel *tunnel;
209
210 if (tpi->proto == htons(ETH_P_TEB))
211 itn = net_generic(net, gre_tap_net_id);
212 else
213 itn = net_generic(net, ipgre_net_id);
214
215 iph = ip_hdr(skb);
216 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
217 iph->saddr, iph->daddr, tpi->key);
218
219 if (tunnel) {
220 ip_tunnel_rcv(tunnel, skb, tpi, log_ecn_error);
221 return PACKET_RCVD;
222 }
223 return PACKET_REJECT;
224 }
225
226 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
227 const struct iphdr *tnl_params,
228 __be16 proto)
229 {
230 struct ip_tunnel *tunnel = netdev_priv(dev);
231 struct tnl_ptk_info tpi;
232
233 tpi.flags = tunnel->parms.o_flags;
234 tpi.proto = proto;
235 tpi.key = tunnel->parms.o_key;
236 if (tunnel->parms.o_flags & TUNNEL_SEQ)
237 tunnel->o_seqno++;
238 tpi.seq = htonl(tunnel->o_seqno);
239
240 /* Push GRE header. */
241 gre_build_header(skb, &tpi, tunnel->hlen);
242
243 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
244 }
245
246 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
247 struct net_device *dev)
248 {
249 struct ip_tunnel *tunnel = netdev_priv(dev);
250 const struct iphdr *tnl_params;
251
252 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
253 if (IS_ERR(skb))
254 goto out;
255
256 if (dev->header_ops) {
257 /* Need space for new headers */
258 if (skb_cow_head(skb, dev->needed_headroom -
259 (tunnel->hlen + sizeof(struct iphdr))))
260 goto free_skb;
261
262 tnl_params = (const struct iphdr *)skb->data;
263
264 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
265 * to gre header.
266 */
267 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
268 } else {
269 if (skb_cow_head(skb, dev->needed_headroom))
270 goto free_skb;
271
272 tnl_params = &tunnel->parms.iph;
273 }
274
275 __gre_xmit(skb, dev, tnl_params, skb->protocol);
276
277 return NETDEV_TX_OK;
278
279 free_skb:
280 dev_kfree_skb(skb);
281 out:
282 dev->stats.tx_dropped++;
283 return NETDEV_TX_OK;
284 }
285
286 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
287 struct net_device *dev)
288 {
289 struct ip_tunnel *tunnel = netdev_priv(dev);
290
291 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
292 if (IS_ERR(skb))
293 goto out;
294
295 if (skb_cow_head(skb, dev->needed_headroom))
296 goto free_skb;
297
298 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
299
300 return NETDEV_TX_OK;
301
302 free_skb:
303 dev_kfree_skb(skb);
304 out:
305 dev->stats.tx_dropped++;
306 return NETDEV_TX_OK;
307 }
308
309 static int ipgre_tunnel_ioctl(struct net_device *dev,
310 struct ifreq *ifr, int cmd)
311 {
312 int err = 0;
313 struct ip_tunnel_parm p;
314
315 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
316 return -EFAULT;
317 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
318 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
319 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
320 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
321 return -EINVAL;
322 }
323 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
324 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
325
326 err = ip_tunnel_ioctl(dev, &p, cmd);
327 if (err)
328 return err;
329
330 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
331 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
332
333 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
334 return -EFAULT;
335 return 0;
336 }
337
338 /* Nice toy. Unfortunately, useless in real life :-)
339 It allows to construct virtual multiprotocol broadcast "LAN"
340 over the Internet, provided multicast routing is tuned.
341
342
343 I have no idea was this bicycle invented before me,
344 so that I had to set ARPHRD_IPGRE to a random value.
345 I have an impression, that Cisco could make something similar,
346 but this feature is apparently missing in IOS<=11.2(8).
347
348 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
349 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
350
351 ping -t 255 224.66.66.66
352
353 If nobody answers, mbone does not work.
354
355 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
356 ip addr add 10.66.66.<somewhat>/24 dev Universe
357 ifconfig Universe up
358 ifconfig Universe add fe80::<Your_real_addr>/10
359 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
360 ftp 10.66.66.66
361 ...
362 ftp fec0:6666:6666::193.233.7.65
363 ...
364 */
365 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
366 unsigned short type,
367 const void *daddr, const void *saddr, unsigned int len)
368 {
369 struct ip_tunnel *t = netdev_priv(dev);
370 struct iphdr *iph;
371 struct gre_base_hdr *greh;
372
373 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
374 greh = (struct gre_base_hdr *)(iph+1);
375 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
376 greh->protocol = htons(type);
377
378 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
379
380 /* Set the source hardware address. */
381 if (saddr)
382 memcpy(&iph->saddr, saddr, 4);
383 if (daddr)
384 memcpy(&iph->daddr, daddr, 4);
385 if (iph->daddr)
386 return t->hlen;
387
388 return -(t->hlen + sizeof(*iph));
389 }
390
391 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
392 {
393 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
394 memcpy(haddr, &iph->saddr, 4);
395 return 4;
396 }
397
398 static const struct header_ops ipgre_header_ops = {
399 .create = ipgre_header,
400 .parse = ipgre_header_parse,
401 };
402
403 #ifdef CONFIG_NET_IPGRE_BROADCAST
404 static int ipgre_open(struct net_device *dev)
405 {
406 struct ip_tunnel *t = netdev_priv(dev);
407
408 if (ipv4_is_multicast(t->parms.iph.daddr)) {
409 struct flowi4 fl4;
410 struct rtable *rt;
411
412 rt = ip_route_output_gre(dev_net(dev), &fl4,
413 t->parms.iph.daddr,
414 t->parms.iph.saddr,
415 t->parms.o_key,
416 RT_TOS(t->parms.iph.tos),
417 t->parms.link);
418 if (IS_ERR(rt))
419 return -EADDRNOTAVAIL;
420 dev = rt->dst.dev;
421 ip_rt_put(rt);
422 if (__in_dev_get_rtnl(dev) == NULL)
423 return -EADDRNOTAVAIL;
424 t->mlink = dev->ifindex;
425 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
426 }
427 return 0;
428 }
429
430 static int ipgre_close(struct net_device *dev)
431 {
432 struct ip_tunnel *t = netdev_priv(dev);
433
434 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
435 struct in_device *in_dev;
436 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
437 if (in_dev)
438 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
439 }
440 return 0;
441 }
442 #endif
443
444 static const struct net_device_ops ipgre_netdev_ops = {
445 .ndo_init = ipgre_tunnel_init,
446 .ndo_uninit = ip_tunnel_uninit,
447 #ifdef CONFIG_NET_IPGRE_BROADCAST
448 .ndo_open = ipgre_open,
449 .ndo_stop = ipgre_close,
450 #endif
451 .ndo_start_xmit = ipgre_xmit,
452 .ndo_do_ioctl = ipgre_tunnel_ioctl,
453 .ndo_change_mtu = ip_tunnel_change_mtu,
454 .ndo_get_stats64 = ip_tunnel_get_stats64,
455 };
456
457 #define GRE_FEATURES (NETIF_F_SG | \
458 NETIF_F_FRAGLIST | \
459 NETIF_F_HIGHDMA | \
460 NETIF_F_HW_CSUM)
461
462 static void ipgre_tunnel_setup(struct net_device *dev)
463 {
464 dev->netdev_ops = &ipgre_netdev_ops;
465 ip_tunnel_setup(dev, ipgre_net_id);
466 }
467
468 static void __gre_tunnel_init(struct net_device *dev)
469 {
470 struct ip_tunnel *tunnel;
471
472 tunnel = netdev_priv(dev);
473 tunnel->hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
474 tunnel->parms.iph.protocol = IPPROTO_GRE;
475
476 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
477 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
478
479 dev->features |= NETIF_F_NETNS_LOCAL | GRE_FEATURES;
480 dev->hw_features |= GRE_FEATURES;
481
482 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
483 /* TCP offload with GRE SEQ is not supported. */
484 dev->features |= NETIF_F_GSO_SOFTWARE;
485 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
486 /* Can use a lockless transmit, unless we generate
487 * output sequences
488 */
489 dev->features |= NETIF_F_LLTX;
490 }
491 }
492
493 static int ipgre_tunnel_init(struct net_device *dev)
494 {
495 struct ip_tunnel *tunnel = netdev_priv(dev);
496 struct iphdr *iph = &tunnel->parms.iph;
497
498 __gre_tunnel_init(dev);
499
500 memcpy(dev->dev_addr, &iph->saddr, 4);
501 memcpy(dev->broadcast, &iph->daddr, 4);
502
503 dev->type = ARPHRD_IPGRE;
504 dev->flags = IFF_NOARP;
505 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
506 dev->addr_len = 4;
507
508 if (iph->daddr) {
509 #ifdef CONFIG_NET_IPGRE_BROADCAST
510 if (ipv4_is_multicast(iph->daddr)) {
511 if (!iph->saddr)
512 return -EINVAL;
513 dev->flags = IFF_BROADCAST;
514 dev->header_ops = &ipgre_header_ops;
515 }
516 #endif
517 } else
518 dev->header_ops = &ipgre_header_ops;
519
520 return ip_tunnel_init(dev);
521 }
522
523 static struct gre_cisco_protocol ipgre_protocol = {
524 .handler = ipgre_rcv,
525 .err_handler = ipgre_err,
526 .priority = 0,
527 };
528
529 static int __net_init ipgre_init_net(struct net *net)
530 {
531 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
532 }
533
534 static void __net_exit ipgre_exit_net(struct net *net)
535 {
536 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
537 ip_tunnel_delete_net(itn);
538 }
539
540 static struct pernet_operations ipgre_net_ops = {
541 .init = ipgre_init_net,
542 .exit = ipgre_exit_net,
543 .id = &ipgre_net_id,
544 .size = sizeof(struct ip_tunnel_net),
545 };
546
547 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
548 {
549 __be16 flags;
550
551 if (!data)
552 return 0;
553
554 flags = 0;
555 if (data[IFLA_GRE_IFLAGS])
556 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
557 if (data[IFLA_GRE_OFLAGS])
558 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
559 if (flags & (GRE_VERSION|GRE_ROUTING))
560 return -EINVAL;
561
562 return 0;
563 }
564
565 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
566 {
567 __be32 daddr;
568
569 if (tb[IFLA_ADDRESS]) {
570 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
571 return -EINVAL;
572 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
573 return -EADDRNOTAVAIL;
574 }
575
576 if (!data)
577 goto out;
578
579 if (data[IFLA_GRE_REMOTE]) {
580 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
581 if (!daddr)
582 return -EINVAL;
583 }
584
585 out:
586 return ipgre_tunnel_validate(tb, data);
587 }
588
589 static void ipgre_netlink_parms(struct nlattr *data[], struct nlattr *tb[],
590 struct ip_tunnel_parm *parms)
591 {
592 memset(parms, 0, sizeof(*parms));
593
594 parms->iph.protocol = IPPROTO_GRE;
595
596 if (!data)
597 return;
598
599 if (data[IFLA_GRE_LINK])
600 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
601
602 if (data[IFLA_GRE_IFLAGS])
603 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
604
605 if (data[IFLA_GRE_OFLAGS])
606 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
607
608 if (data[IFLA_GRE_IKEY])
609 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
610
611 if (data[IFLA_GRE_OKEY])
612 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
613
614 if (data[IFLA_GRE_LOCAL])
615 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
616
617 if (data[IFLA_GRE_REMOTE])
618 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
619
620 if (data[IFLA_GRE_TTL])
621 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
622
623 if (data[IFLA_GRE_TOS])
624 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
625
626 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
627 parms->iph.frag_off = htons(IP_DF);
628 }
629
630 static int gre_tap_init(struct net_device *dev)
631 {
632 __gre_tunnel_init(dev);
633
634 return ip_tunnel_init(dev);
635 }
636
637 static const struct net_device_ops gre_tap_netdev_ops = {
638 .ndo_init = gre_tap_init,
639 .ndo_uninit = ip_tunnel_uninit,
640 .ndo_start_xmit = gre_tap_xmit,
641 .ndo_set_mac_address = eth_mac_addr,
642 .ndo_validate_addr = eth_validate_addr,
643 .ndo_change_mtu = ip_tunnel_change_mtu,
644 .ndo_get_stats64 = ip_tunnel_get_stats64,
645 };
646
647 static void ipgre_tap_setup(struct net_device *dev)
648 {
649 ether_setup(dev);
650 dev->netdev_ops = &gre_tap_netdev_ops;
651 ip_tunnel_setup(dev, gre_tap_net_id);
652 }
653
654 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
655 struct nlattr *tb[], struct nlattr *data[])
656 {
657 struct ip_tunnel_parm p;
658
659 ipgre_netlink_parms(data, tb, &p);
660 return ip_tunnel_newlink(dev, tb, &p);
661 }
662
663 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
664 struct nlattr *data[])
665 {
666 struct ip_tunnel_parm p;
667
668 ipgre_netlink_parms(data, tb, &p);
669 return ip_tunnel_changelink(dev, tb, &p);
670 }
671
672 static size_t ipgre_get_size(const struct net_device *dev)
673 {
674 return
675 /* IFLA_GRE_LINK */
676 nla_total_size(4) +
677 /* IFLA_GRE_IFLAGS */
678 nla_total_size(2) +
679 /* IFLA_GRE_OFLAGS */
680 nla_total_size(2) +
681 /* IFLA_GRE_IKEY */
682 nla_total_size(4) +
683 /* IFLA_GRE_OKEY */
684 nla_total_size(4) +
685 /* IFLA_GRE_LOCAL */
686 nla_total_size(4) +
687 /* IFLA_GRE_REMOTE */
688 nla_total_size(4) +
689 /* IFLA_GRE_TTL */
690 nla_total_size(1) +
691 /* IFLA_GRE_TOS */
692 nla_total_size(1) +
693 /* IFLA_GRE_PMTUDISC */
694 nla_total_size(1) +
695 0;
696 }
697
698 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
699 {
700 struct ip_tunnel *t = netdev_priv(dev);
701 struct ip_tunnel_parm *p = &t->parms;
702
703 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
704 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
705 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
706 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
707 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
708 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
709 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
710 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
711 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
712 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
713 !!(p->iph.frag_off & htons(IP_DF))))
714 goto nla_put_failure;
715 return 0;
716
717 nla_put_failure:
718 return -EMSGSIZE;
719 }
720
721 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
722 [IFLA_GRE_LINK] = { .type = NLA_U32 },
723 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
724 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
725 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
726 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
727 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
728 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
729 [IFLA_GRE_TTL] = { .type = NLA_U8 },
730 [IFLA_GRE_TOS] = { .type = NLA_U8 },
731 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
732 };
733
734 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
735 .kind = "gre",
736 .maxtype = IFLA_GRE_MAX,
737 .policy = ipgre_policy,
738 .priv_size = sizeof(struct ip_tunnel),
739 .setup = ipgre_tunnel_setup,
740 .validate = ipgre_tunnel_validate,
741 .newlink = ipgre_newlink,
742 .changelink = ipgre_changelink,
743 .dellink = ip_tunnel_dellink,
744 .get_size = ipgre_get_size,
745 .fill_info = ipgre_fill_info,
746 };
747
748 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
749 .kind = "gretap",
750 .maxtype = IFLA_GRE_MAX,
751 .policy = ipgre_policy,
752 .priv_size = sizeof(struct ip_tunnel),
753 .setup = ipgre_tap_setup,
754 .validate = ipgre_tap_validate,
755 .newlink = ipgre_newlink,
756 .changelink = ipgre_changelink,
757 .dellink = ip_tunnel_dellink,
758 .get_size = ipgre_get_size,
759 .fill_info = ipgre_fill_info,
760 };
761
762 static int __net_init ipgre_tap_init_net(struct net *net)
763 {
764 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, NULL);
765 }
766
767 static void __net_exit ipgre_tap_exit_net(struct net *net)
768 {
769 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
770 ip_tunnel_delete_net(itn);
771 }
772
773 static struct pernet_operations ipgre_tap_net_ops = {
774 .init = ipgre_tap_init_net,
775 .exit = ipgre_tap_exit_net,
776 .id = &gre_tap_net_id,
777 .size = sizeof(struct ip_tunnel_net),
778 };
779
780 static int __init ipgre_init(void)
781 {
782 int err;
783
784 pr_info("GRE over IPv4 tunneling driver\n");
785
786 err = register_pernet_device(&ipgre_net_ops);
787 if (err < 0)
788 return err;
789
790 err = register_pernet_device(&ipgre_tap_net_ops);
791 if (err < 0)
792 goto pnet_tap_faied;
793
794 err = gre_cisco_register(&ipgre_protocol);
795 if (err < 0) {
796 pr_info("%s: can't add protocol\n", __func__);
797 goto add_proto_failed;
798 }
799
800 err = rtnl_link_register(&ipgre_link_ops);
801 if (err < 0)
802 goto rtnl_link_failed;
803
804 err = rtnl_link_register(&ipgre_tap_ops);
805 if (err < 0)
806 goto tap_ops_failed;
807
808 return 0;
809
810 tap_ops_failed:
811 rtnl_link_unregister(&ipgre_link_ops);
812 rtnl_link_failed:
813 gre_cisco_unregister(&ipgre_protocol);
814 add_proto_failed:
815 unregister_pernet_device(&ipgre_tap_net_ops);
816 pnet_tap_faied:
817 unregister_pernet_device(&ipgre_net_ops);
818 return err;
819 }
820
821 static void __exit ipgre_fini(void)
822 {
823 rtnl_link_unregister(&ipgre_tap_ops);
824 rtnl_link_unregister(&ipgre_link_ops);
825 gre_cisco_unregister(&ipgre_protocol);
826 unregister_pernet_device(&ipgre_tap_net_ops);
827 unregister_pernet_device(&ipgre_net_ops);
828 }
829
830 module_init(ipgre_init);
831 module_exit(ipgre_fini);
832 MODULE_LICENSE("GPL");
833 MODULE_ALIAS_RTNL_LINK("gre");
834 MODULE_ALIAS_RTNL_LINK("gretap");
835 MODULE_ALIAS_NETDEV("gre0");
836 MODULE_ALIAS_NETDEV("gretap0");
Linus' kernel tree