?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mmc: omap_hsmmc: remove unused get_context_loss_count callback
[linux-2.6/btrfs-unstable.git] / net / ipv4 / ip_gre.c
blob12055fdbe716f0f1d905f288cbe36415f0e4f592
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 *)(icmp_hdr(skb) + 1);
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 skb_pop_mac_header(skb);
221 ip_tunnel_rcv(tunnel, skb, tpi, log_ecn_error);
222 return PACKET_RCVD;
223 }
224 return PACKET_REJECT;
225 }
226
227 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
228 const struct iphdr *tnl_params,
229 __be16 proto)
230 {
231 struct ip_tunnel *tunnel = netdev_priv(dev);
232 struct tnl_ptk_info tpi;
233
234 tpi.flags = tunnel->parms.o_flags;
235 tpi.proto = proto;
236 tpi.key = tunnel->parms.o_key;
237 if (tunnel->parms.o_flags & TUNNEL_SEQ)
238 tunnel->o_seqno++;
239 tpi.seq = htonl(tunnel->o_seqno);
240
241 /* Push GRE header. */
242 gre_build_header(skb, &tpi, tunnel->tun_hlen);
243
244 skb_set_inner_protocol(skb, tpi.proto);
245
246 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
247 }
248
249 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
250 struct net_device *dev)
251 {
252 struct ip_tunnel *tunnel = netdev_priv(dev);
253 const struct iphdr *tnl_params;
254
255 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
256 if (IS_ERR(skb))
257 goto out;
258
259 if (dev->header_ops) {
260 /* Need space for new headers */
261 if (skb_cow_head(skb, dev->needed_headroom -
262 (tunnel->hlen + sizeof(struct iphdr))))
263 goto free_skb;
264
265 tnl_params = (const struct iphdr *)skb->data;
266
267 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
268 * to gre header.
269 */
270 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
271 } else {
272 if (skb_cow_head(skb, dev->needed_headroom))
273 goto free_skb;
274
275 tnl_params = &tunnel->parms.iph;
276 }
277
278 __gre_xmit(skb, dev, tnl_params, skb->protocol);
279
280 return NETDEV_TX_OK;
281
282 free_skb:
283 kfree_skb(skb);
284 out:
285 dev->stats.tx_dropped++;
286 return NETDEV_TX_OK;
287 }
288
289 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
290 struct net_device *dev)
291 {
292 struct ip_tunnel *tunnel = netdev_priv(dev);
293
294 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
295 if (IS_ERR(skb))
296 goto out;
297
298 if (skb_cow_head(skb, dev->needed_headroom))
299 goto free_skb;
300
301 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
302
303 return NETDEV_TX_OK;
304
305 free_skb:
306 kfree_skb(skb);
307 out:
308 dev->stats.tx_dropped++;
309 return NETDEV_TX_OK;
310 }
311
312 static int ipgre_tunnel_ioctl(struct net_device *dev,
313 struct ifreq *ifr, int cmd)
314 {
315 int err;
316 struct ip_tunnel_parm p;
317
318 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
319 return -EFAULT;
320 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
321 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
322 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
323 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
324 return -EINVAL;
325 }
326 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
327 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
328
329 err = ip_tunnel_ioctl(dev, &p, cmd);
330 if (err)
331 return err;
332
333 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
334 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
335
336 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
337 return -EFAULT;
338 return 0;
339 }
340
341 /* Nice toy. Unfortunately, useless in real life :-)
342 It allows to construct virtual multiprotocol broadcast "LAN"
343 over the Internet, provided multicast routing is tuned.
344
345
346 I have no idea was this bicycle invented before me,
347 so that I had to set ARPHRD_IPGRE to a random value.
348 I have an impression, that Cisco could make something similar,
349 but this feature is apparently missing in IOS<=11.2(8).
350
351 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
352 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
353
354 ping -t 255 224.66.66.66
355
356 If nobody answers, mbone does not work.
357
358 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
359 ip addr add 10.66.66.<somewhat>/24 dev Universe
360 ifconfig Universe up
361 ifconfig Universe add fe80::<Your_real_addr>/10
362 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
363 ftp 10.66.66.66
364 ...
365 ftp fec0:6666:6666::193.233.7.65
366 ...
367 */
368 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
369 unsigned short type,
370 const void *daddr, const void *saddr, unsigned int len)
371 {
372 struct ip_tunnel *t = netdev_priv(dev);
373 struct iphdr *iph;
374 struct gre_base_hdr *greh;
375
376 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
377 greh = (struct gre_base_hdr *)(iph+1);
378 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
379 greh->protocol = htons(type);
380
381 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
382
383 /* Set the source hardware address. */
384 if (saddr)
385 memcpy(&iph->saddr, saddr, 4);
386 if (daddr)
387 memcpy(&iph->daddr, daddr, 4);
388 if (iph->daddr)
389 return t->hlen + sizeof(*iph);
390
391 return -(t->hlen + sizeof(*iph));
392 }
393
394 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
395 {
396 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
397 memcpy(haddr, &iph->saddr, 4);
398 return 4;
399 }
400
401 static const struct header_ops ipgre_header_ops = {
402 .create = ipgre_header,
403 .parse = ipgre_header_parse,
404 };
405
406 #ifdef CONFIG_NET_IPGRE_BROADCAST
407 static int ipgre_open(struct net_device *dev)
408 {
409 struct ip_tunnel *t = netdev_priv(dev);
410
411 if (ipv4_is_multicast(t->parms.iph.daddr)) {
412 struct flowi4 fl4;
413 struct rtable *rt;
414
415 rt = ip_route_output_gre(t->net, &fl4,
416 t->parms.iph.daddr,
417 t->parms.iph.saddr,
418 t->parms.o_key,
419 RT_TOS(t->parms.iph.tos),
420 t->parms.link);
421 if (IS_ERR(rt))
422 return -EADDRNOTAVAIL;
423 dev = rt->dst.dev;
424 ip_rt_put(rt);
425 if (__in_dev_get_rtnl(dev) == NULL)
426 return -EADDRNOTAVAIL;
427 t->mlink = dev->ifindex;
428 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
429 }
430 return 0;
431 }
432
433 static int ipgre_close(struct net_device *dev)
434 {
435 struct ip_tunnel *t = netdev_priv(dev);
436
437 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
438 struct in_device *in_dev;
439 in_dev = inetdev_by_index(t->net, t->mlink);
440 if (in_dev)
441 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
442 }
443 return 0;
444 }
445 #endif
446
447 static const struct net_device_ops ipgre_netdev_ops = {
448 .ndo_init = ipgre_tunnel_init,
449 .ndo_uninit = ip_tunnel_uninit,
450 #ifdef CONFIG_NET_IPGRE_BROADCAST
451 .ndo_open = ipgre_open,
452 .ndo_stop = ipgre_close,
453 #endif
454 .ndo_start_xmit = ipgre_xmit,
455 .ndo_do_ioctl = ipgre_tunnel_ioctl,
456 .ndo_change_mtu = ip_tunnel_change_mtu,
457 .ndo_get_stats64 = ip_tunnel_get_stats64,
458 };
459
460 #define GRE_FEATURES (NETIF_F_SG | \
461 NETIF_F_FRAGLIST | \
462 NETIF_F_HIGHDMA | \
463 NETIF_F_HW_CSUM)
464
465 static void ipgre_tunnel_setup(struct net_device *dev)
466 {
467 dev->netdev_ops = &ipgre_netdev_ops;
468 dev->type = ARPHRD_IPGRE;
469 ip_tunnel_setup(dev, ipgre_net_id);
470 }
471
472 static void __gre_tunnel_init(struct net_device *dev)
473 {
474 struct ip_tunnel *tunnel;
475 int t_hlen;
476
477 tunnel = netdev_priv(dev);
478 tunnel->tun_hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
479 tunnel->parms.iph.protocol = IPPROTO_GRE;
480
481 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
482
483 t_hlen = tunnel->hlen + sizeof(struct iphdr);
484
485 dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4;
486 dev->mtu = ETH_DATA_LEN - t_hlen - 4;
487
488 dev->features |= GRE_FEATURES;
489 dev->hw_features |= GRE_FEATURES;
490
491 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
492 /* TCP offload with GRE SEQ is not supported. */
493 dev->features |= NETIF_F_GSO_SOFTWARE;
494 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
495 /* Can use a lockless transmit, unless we generate
496 * output sequences
497 */
498 dev->features |= NETIF_F_LLTX;
499 }
500 }
501
502 static int ipgre_tunnel_init(struct net_device *dev)
503 {
504 struct ip_tunnel *tunnel = netdev_priv(dev);
505 struct iphdr *iph = &tunnel->parms.iph;
506
507 __gre_tunnel_init(dev);
508
509 memcpy(dev->dev_addr, &iph->saddr, 4);
510 memcpy(dev->broadcast, &iph->daddr, 4);
511
512 dev->flags = IFF_NOARP;
513 netif_keep_dst(dev);
514 dev->addr_len = 4;
515
516 if (iph->daddr) {
517 #ifdef CONFIG_NET_IPGRE_BROADCAST
518 if (ipv4_is_multicast(iph->daddr)) {
519 if (!iph->saddr)
520 return -EINVAL;
521 dev->flags = IFF_BROADCAST;
522 dev->header_ops = &ipgre_header_ops;
523 }
524 #endif
525 } else
526 dev->header_ops = &ipgre_header_ops;
527
528 return ip_tunnel_init(dev);
529 }
530
531 static struct gre_cisco_protocol ipgre_protocol = {
532 .handler = ipgre_rcv,
533 .err_handler = ipgre_err,
534 .priority = 0,
535 };
536
537 static int __net_init ipgre_init_net(struct net *net)
538 {
539 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
540 }
541
542 static void __net_exit ipgre_exit_net(struct net *net)
543 {
544 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
545 ip_tunnel_delete_net(itn, &ipgre_link_ops);
546 }
547
548 static struct pernet_operations ipgre_net_ops = {
549 .init = ipgre_init_net,
550 .exit = ipgre_exit_net,
551 .id = &ipgre_net_id,
552 .size = sizeof(struct ip_tunnel_net),
553 };
554
555 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
556 {
557 __be16 flags;
558
559 if (!data)
560 return 0;
561
562 flags = 0;
563 if (data[IFLA_GRE_IFLAGS])
564 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
565 if (data[IFLA_GRE_OFLAGS])
566 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
567 if (flags & (GRE_VERSION|GRE_ROUTING))
568 return -EINVAL;
569
570 return 0;
571 }
572
573 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
574 {
575 __be32 daddr;
576
577 if (tb[IFLA_ADDRESS]) {
578 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
579 return -EINVAL;
580 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
581 return -EADDRNOTAVAIL;
582 }
583
584 if (!data)
585 goto out;
586
587 if (data[IFLA_GRE_REMOTE]) {
588 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
589 if (!daddr)
590 return -EINVAL;
591 }
592
593 out:
594 return ipgre_tunnel_validate(tb, data);
595 }
596
597 static void ipgre_netlink_parms(struct nlattr *data[], struct nlattr *tb[],
598 struct ip_tunnel_parm *parms)
599 {
600 memset(parms, 0, sizeof(*parms));
601
602 parms->iph.protocol = IPPROTO_GRE;
603
604 if (!data)
605 return;
606
607 if (data[IFLA_GRE_LINK])
608 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
609
610 if (data[IFLA_GRE_IFLAGS])
611 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
612
613 if (data[IFLA_GRE_OFLAGS])
614 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
615
616 if (data[IFLA_GRE_IKEY])
617 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
618
619 if (data[IFLA_GRE_OKEY])
620 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
621
622 if (data[IFLA_GRE_LOCAL])
623 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
624
625 if (data[IFLA_GRE_REMOTE])
626 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
627
628 if (data[IFLA_GRE_TTL])
629 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
630
631 if (data[IFLA_GRE_TOS])
632 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
633
634 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
635 parms->iph.frag_off = htons(IP_DF);
636 }
637
638 /* This function returns true when ENCAP attributes are present in the nl msg */
639 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
640 struct ip_tunnel_encap *ipencap)
641 {
642 bool ret = false;
643
644 memset(ipencap, 0, sizeof(*ipencap));
645
646 if (!data)
647 return ret;
648
649 if (data[IFLA_GRE_ENCAP_TYPE]) {
650 ret = true;
651 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
652 }
653
654 if (data[IFLA_GRE_ENCAP_FLAGS]) {
655 ret = true;
656 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
657 }
658
659 if (data[IFLA_GRE_ENCAP_SPORT]) {
660 ret = true;
661 ipencap->sport = nla_get_u16(data[IFLA_GRE_ENCAP_SPORT]);
662 }
663
664 if (data[IFLA_GRE_ENCAP_DPORT]) {
665 ret = true;
666 ipencap->dport = nla_get_u16(data[IFLA_GRE_ENCAP_DPORT]);
667 }
668
669 return ret;
670 }
671
672 static int gre_tap_init(struct net_device *dev)
673 {
674 __gre_tunnel_init(dev);
675
676 return ip_tunnel_init(dev);
677 }
678
679 static const struct net_device_ops gre_tap_netdev_ops = {
680 .ndo_init = gre_tap_init,
681 .ndo_uninit = ip_tunnel_uninit,
682 .ndo_start_xmit = gre_tap_xmit,
683 .ndo_set_mac_address = eth_mac_addr,
684 .ndo_validate_addr = eth_validate_addr,
685 .ndo_change_mtu = ip_tunnel_change_mtu,
686 .ndo_get_stats64 = ip_tunnel_get_stats64,
687 };
688
689 static void ipgre_tap_setup(struct net_device *dev)
690 {
691 ether_setup(dev);
692 dev->netdev_ops = &gre_tap_netdev_ops;
693 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
694 ip_tunnel_setup(dev, gre_tap_net_id);
695 }
696
697 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
698 struct nlattr *tb[], struct nlattr *data[])
699 {
700 struct ip_tunnel_parm p;
701 struct ip_tunnel_encap ipencap;
702
703 if (ipgre_netlink_encap_parms(data, &ipencap)) {
704 struct ip_tunnel *t = netdev_priv(dev);
705 int err = ip_tunnel_encap_setup(t, &ipencap);
706
707 if (err < 0)
708 return err;
709 }
710
711 ipgre_netlink_parms(data, tb, &p);
712 return ip_tunnel_newlink(dev, tb, &p);
713 }
714
715 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
716 struct nlattr *data[])
717 {
718 struct ip_tunnel_parm p;
719 struct ip_tunnel_encap ipencap;
720
721 if (ipgre_netlink_encap_parms(data, &ipencap)) {
722 struct ip_tunnel *t = netdev_priv(dev);
723 int err = ip_tunnel_encap_setup(t, &ipencap);
724
725 if (err < 0)
726 return err;
727 }
728
729 ipgre_netlink_parms(data, tb, &p);
730 return ip_tunnel_changelink(dev, tb, &p);
731 }
732
733 static size_t ipgre_get_size(const struct net_device *dev)
734 {
735 return
736 /* IFLA_GRE_LINK */
737 nla_total_size(4) +
738 /* IFLA_GRE_IFLAGS */
739 nla_total_size(2) +
740 /* IFLA_GRE_OFLAGS */
741 nla_total_size(2) +
742 /* IFLA_GRE_IKEY */
743 nla_total_size(4) +
744 /* IFLA_GRE_OKEY */
745 nla_total_size(4) +
746 /* IFLA_GRE_LOCAL */
747 nla_total_size(4) +
748 /* IFLA_GRE_REMOTE */
749 nla_total_size(4) +
750 /* IFLA_GRE_TTL */
751 nla_total_size(1) +
752 /* IFLA_GRE_TOS */
753 nla_total_size(1) +
754 /* IFLA_GRE_PMTUDISC */
755 nla_total_size(1) +
756 /* IFLA_GRE_ENCAP_TYPE */
757 nla_total_size(2) +
758 /* IFLA_GRE_ENCAP_FLAGS */
759 nla_total_size(2) +
760 /* IFLA_GRE_ENCAP_SPORT */
761 nla_total_size(2) +
762 /* IFLA_GRE_ENCAP_DPORT */
763 nla_total_size(2) +
764 0;
765 }
766
767 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
768 {
769 struct ip_tunnel *t = netdev_priv(dev);
770 struct ip_tunnel_parm *p = &t->parms;
771
772 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
773 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
774 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
775 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
776 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
777 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
778 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
779 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
780 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
781 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
782 !!(p->iph.frag_off & htons(IP_DF))))
783 goto nla_put_failure;
784
785 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
786 t->encap.type) ||
787 nla_put_u16(skb, IFLA_GRE_ENCAP_SPORT,
788 t->encap.sport) ||
789 nla_put_u16(skb, IFLA_GRE_ENCAP_DPORT,
790 t->encap.dport) ||
791 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
792 t->encap.dport))
793 goto nla_put_failure;
794
795 return 0;
796
797 nla_put_failure:
798 return -EMSGSIZE;
799 }
800
801 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
802 [IFLA_GRE_LINK] = { .type = NLA_U32 },
803 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
804 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
805 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
806 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
807 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
808 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
809 [IFLA_GRE_TTL] = { .type = NLA_U8 },
810 [IFLA_GRE_TOS] = { .type = NLA_U8 },
811 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
812 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
813 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
814 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
815 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
816 };
817
818 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
819 .kind = "gre",
820 .maxtype = IFLA_GRE_MAX,
821 .policy = ipgre_policy,
822 .priv_size = sizeof(struct ip_tunnel),
823 .setup = ipgre_tunnel_setup,
824 .validate = ipgre_tunnel_validate,
825 .newlink = ipgre_newlink,
826 .changelink = ipgre_changelink,
827 .dellink = ip_tunnel_dellink,
828 .get_size = ipgre_get_size,
829 .fill_info = ipgre_fill_info,
830 };
831
832 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
833 .kind = "gretap",
834 .maxtype = IFLA_GRE_MAX,
835 .policy = ipgre_policy,
836 .priv_size = sizeof(struct ip_tunnel),
837 .setup = ipgre_tap_setup,
838 .validate = ipgre_tap_validate,
839 .newlink = ipgre_newlink,
840 .changelink = ipgre_changelink,
841 .dellink = ip_tunnel_dellink,
842 .get_size = ipgre_get_size,
843 .fill_info = ipgre_fill_info,
844 };
845
846 static int __net_init ipgre_tap_init_net(struct net *net)
847 {
848 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, NULL);
849 }
850
851 static void __net_exit ipgre_tap_exit_net(struct net *net)
852 {
853 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
854 ip_tunnel_delete_net(itn, &ipgre_tap_ops);
855 }
856
857 static struct pernet_operations ipgre_tap_net_ops = {
858 .init = ipgre_tap_init_net,
859 .exit = ipgre_tap_exit_net,
860 .id = &gre_tap_net_id,
861 .size = sizeof(struct ip_tunnel_net),
862 };
863
864 static int __init ipgre_init(void)
865 {
866 int err;
867
868 pr_info("GRE over IPv4 tunneling driver\n");
869
870 err = register_pernet_device(&ipgre_net_ops);
871 if (err < 0)
872 return err;
873
874 err = register_pernet_device(&ipgre_tap_net_ops);
875 if (err < 0)
876 goto pnet_tap_faied;
877
878 err = gre_cisco_register(&ipgre_protocol);
879 if (err < 0) {
880 pr_info("%s: can't add protocol\n", __func__);
881 goto add_proto_failed;
882 }
883
884 err = rtnl_link_register(&ipgre_link_ops);
885 if (err < 0)
886 goto rtnl_link_failed;
887
888 err = rtnl_link_register(&ipgre_tap_ops);
889 if (err < 0)
890 goto tap_ops_failed;
891
892 return 0;
893
894 tap_ops_failed:
895 rtnl_link_unregister(&ipgre_link_ops);
896 rtnl_link_failed:
897 gre_cisco_unregister(&ipgre_protocol);
898 add_proto_failed:
899 unregister_pernet_device(&ipgre_tap_net_ops);
900 pnet_tap_faied:
901 unregister_pernet_device(&ipgre_net_ops);
902 return err;
903 }
904
905 static void __exit ipgre_fini(void)
906 {
907 rtnl_link_unregister(&ipgre_tap_ops);
908 rtnl_link_unregister(&ipgre_link_ops);
909 gre_cisco_unregister(&ipgre_protocol);
910 unregister_pernet_device(&ipgre_tap_net_ops);
911 unregister_pernet_device(&ipgre_net_ops);
912 }
913
914 module_init(ipgre_init);
915 module_exit(ipgre_fini);
916 MODULE_LICENSE("GPL");
917 MODULE_ALIAS_RTNL_LINK("gre");
918 MODULE_ALIAS_RTNL_LINK("gretap");
919 MODULE_ALIAS_NETDEV("gre0");
920 MODULE_ALIAS_NETDEV("gretap0");
(deprecated) Btrfs devel tree