1
2
3
4
5
6
7
8
9
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/if_vlan.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#include <net/dst_metadata.h>
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109static bool log_ecn_error = true;
110module_param(log_ecn_error, bool, 0644);
111MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
112
113static struct rtnl_link_ops ipgre_link_ops __read_mostly;
114static int ipgre_tunnel_init(struct net_device *dev);
115
116static int ipgre_net_id __read_mostly;
117static int gre_tap_net_id __read_mostly;
118
119static void ipgre_err(struct sk_buff *skb, u32 info,
120 const struct tnl_ptk_info *tpi)
121{
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136 struct net *net = dev_net(skb->dev);
137 struct ip_tunnel_net *itn;
138 const struct iphdr *iph;
139 const int type = icmp_hdr(skb)->type;
140 const int code = icmp_hdr(skb)->code;
141 struct ip_tunnel *t;
142
143 switch (type) {
144 default:
145 case ICMP_PARAMETERPROB:
146 return;
147
148 case ICMP_DEST_UNREACH:
149 switch (code) {
150 case ICMP_SR_FAILED:
151 case ICMP_PORT_UNREACH:
152
153 return;
154 default:
155
156
157
158
159 break;
160 }
161 break;
162
163 case ICMP_TIME_EXCEEDED:
164 if (code != ICMP_EXC_TTL)
165 return;
166 break;
167
168 case ICMP_REDIRECT:
169 break;
170 }
171
172 if (tpi->proto == htons(ETH_P_TEB))
173 itn = net_generic(net, gre_tap_net_id);
174 else
175 itn = net_generic(net, ipgre_net_id);
176
177 iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
178 t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
179 iph->daddr, iph->saddr, tpi->key);
180
181 if (t == NULL)
182 return;
183
184 if (t->parms.iph.daddr == 0 ||
185 ipv4_is_multicast(t->parms.iph.daddr))
186 return;
187
188 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
189 return;
190
191 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
192 t->err_count++;
193 else
194 t->err_count = 1;
195 t->err_time = jiffies;
196}
197
198static void gre_err(struct sk_buff *skb, u32 info)
199{
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214 const struct iphdr *iph = (struct iphdr *)skb->data;
215 const int type = icmp_hdr(skb)->type;
216 const int code = icmp_hdr(skb)->code;
217 struct tnl_ptk_info tpi;
218
219 if (gre_parse_header(skb, &tpi, NULL, htons(ETH_P_IP),
220 iph->ihl * 4) < 0)
221 return;
222
223 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
224 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
225 skb->dev->ifindex, 0, IPPROTO_GRE, 0);
226 return;
227 }
228 if (type == ICMP_REDIRECT) {
229 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0,
230 IPPROTO_GRE, 0);
231 return;
232 }
233
234 ipgre_err(skb, info, &tpi);
235}
236
237static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
238 struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
239{
240 struct metadata_dst *tun_dst = NULL;
241 const struct iphdr *iph;
242 struct ip_tunnel *tunnel;
243
244 iph = ip_hdr(skb);
245 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
246 iph->saddr, iph->daddr, tpi->key);
247
248 if (tunnel) {
249 if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
250 raw_proto, false) < 0)
251 goto drop;
252
253 if (tunnel->dev->type != ARPHRD_NONE)
254 skb_pop_mac_header(skb);
255 else
256 skb_reset_mac_header(skb);
257 if (tunnel->collect_md) {
258 __be16 flags;
259 __be64 tun_id;
260
261 flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
262 tun_id = key32_to_tunnel_id(tpi->key);
263 tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
264 if (!tun_dst)
265 return PACKET_REJECT;
266 }
267
268 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
269 return PACKET_RCVD;
270 }
271 return PACKET_NEXT;
272
273drop:
274 kfree_skb(skb);
275 return PACKET_RCVD;
276}
277
278static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
279 int hdr_len)
280{
281 struct net *net = dev_net(skb->dev);
282 struct ip_tunnel_net *itn;
283 int res;
284
285 if (tpi->proto == htons(ETH_P_TEB))
286 itn = net_generic(net, gre_tap_net_id);
287 else
288 itn = net_generic(net, ipgre_net_id);
289
290 res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
291 if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
292
293
294
295 itn = net_generic(net, ipgre_net_id);
296 res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
297 }
298 return res;
299}
300
301static int gre_rcv(struct sk_buff *skb)
302{
303 struct tnl_ptk_info tpi;
304 bool csum_err = false;
305 int hdr_len;
306
307#ifdef CONFIG_NET_IPGRE_BROADCAST
308 if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
309
310 if (rt_is_output_route(skb_rtable(skb)))
311 goto drop;
312 }
313#endif
314
315 hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
316 if (hdr_len < 0)
317 goto drop;
318
319 if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
320 return 0;
321
322 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
323drop:
324 kfree_skb(skb);
325 return 0;
326}
327
328static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
329 const struct iphdr *tnl_params,
330 __be16 proto)
331{
332 struct ip_tunnel *tunnel = netdev_priv(dev);
333
334 if (tunnel->parms.o_flags & TUNNEL_SEQ)
335 tunnel->o_seqno++;
336
337
338 gre_build_header(skb, tunnel->tun_hlen,
339 tunnel->parms.o_flags, proto, tunnel->parms.o_key,
340 htonl(tunnel->o_seqno));
341
342 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
343}
344
345static int gre_handle_offloads(struct sk_buff *skb, bool csum)
346{
347 return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
348}
349
350static struct rtable *gre_get_rt(struct sk_buff *skb,
351 struct net_device *dev,
352 struct flowi4 *fl,
353 const struct ip_tunnel_key *key)
354{
355 struct net *net = dev_net(dev);
356
357 memset(fl, 0, sizeof(*fl));
358 fl->daddr = key->u.ipv4.dst;
359 fl->saddr = key->u.ipv4.src;
360 fl->flowi4_tos = RT_TOS(key->tos);
361 fl->flowi4_mark = skb->mark;
362 fl->flowi4_proto = IPPROTO_GRE;
363
364 return ip_route_output_key(net, fl);
365}
366
367static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
368 __be16 proto)
369{
370 struct ip_tunnel_info *tun_info;
371 const struct ip_tunnel_key *key;
372 struct rtable *rt = NULL;
373 struct flowi4 fl;
374 int min_headroom;
375 int tunnel_hlen;
376 __be16 df, flags;
377 bool use_cache;
378 int err;
379
380 tun_info = skb_tunnel_info(skb);
381 if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
382 ip_tunnel_info_af(tun_info) != AF_INET))
383 goto err_free_skb;
384
385 key = &tun_info->key;
386 use_cache = ip_tunnel_dst_cache_usable(skb, tun_info);
387 if (use_cache)
388 rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr);
389 if (!rt) {
390 rt = gre_get_rt(skb, dev, &fl, key);
391 if (IS_ERR(rt))
392 goto err_free_skb;
393 if (use_cache)
394 dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,
395 fl.saddr);
396 }
397
398 tunnel_hlen = gre_calc_hlen(key->tun_flags);
399
400 min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
401 + tunnel_hlen + sizeof(struct iphdr);
402 if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
403 int head_delta = SKB_DATA_ALIGN(min_headroom -
404 skb_headroom(skb) +
405 16);
406 err = pskb_expand_head(skb, max_t(int, head_delta, 0),
407 0, GFP_ATOMIC);
408 if (unlikely(err))
409 goto err_free_rt;
410 }
411
412
413 if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
414 goto err_free_rt;
415
416 flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
417 gre_build_header(skb, tunnel_hlen, flags, proto,
418 tunnel_id_to_key32(tun_info->key.tun_id), 0);
419
420 df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
421
422 iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE,
423 key->tos, key->ttl, df, false);
424 return;
425
426err_free_rt:
427 ip_rt_put(rt);
428err_free_skb:
429 kfree_skb(skb);
430 dev->stats.tx_dropped++;
431}
432
433static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
434{
435 struct ip_tunnel_info *info = skb_tunnel_info(skb);
436 struct rtable *rt;
437 struct flowi4 fl4;
438
439 if (ip_tunnel_info_af(info) != AF_INET)
440 return -EINVAL;
441
442 rt = gre_get_rt(skb, dev, &fl4, &info->key);
443 if (IS_ERR(rt))
444 return PTR_ERR(rt);
445
446 ip_rt_put(rt);
447 info->key.u.ipv4.src = fl4.saddr;
448 return 0;
449}
450
451static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
452 struct net_device *dev)
453{
454 struct ip_tunnel *tunnel = netdev_priv(dev);
455 const struct iphdr *tnl_params;
456
457 if (tunnel->collect_md) {
458 gre_fb_xmit(skb, dev, skb->protocol);
459 return NETDEV_TX_OK;
460 }
461
462 if (dev->header_ops) {
463
464 if (skb_cow_head(skb, dev->needed_headroom -
465 (tunnel->hlen + sizeof(struct iphdr))))
466 goto free_skb;
467
468 tnl_params = (const struct iphdr *)skb->data;
469
470
471
472
473 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
474 skb_reset_mac_header(skb);
475 } else {
476 if (skb_cow_head(skb, dev->needed_headroom))
477 goto free_skb;
478
479 tnl_params = &tunnel->parms.iph;
480 }
481
482 if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
483 goto free_skb;
484
485 __gre_xmit(skb, dev, tnl_params, skb->protocol);
486 return NETDEV_TX_OK;
487
488free_skb:
489 kfree_skb(skb);
490 dev->stats.tx_dropped++;
491 return NETDEV_TX_OK;
492}
493
494static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
495 struct net_device *dev)
496{
497 struct ip_tunnel *tunnel = netdev_priv(dev);
498
499 if (tunnel->collect_md) {
500 gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
501 return NETDEV_TX_OK;
502 }
503
504 if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
505 goto free_skb;
506
507 if (skb_cow_head(skb, dev->needed_headroom))
508 goto free_skb;
509
510 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
511 return NETDEV_TX_OK;
512
513free_skb:
514 kfree_skb(skb);
515 dev->stats.tx_dropped++;
516 return NETDEV_TX_OK;
517}
518
519static void ipgre_link_update(struct net_device *dev, bool set_mtu)
520{
521 struct ip_tunnel *tunnel = netdev_priv(dev);
522 int len;
523
524 len = tunnel->tun_hlen;
525 tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
526 len = tunnel->tun_hlen - len;
527 tunnel->hlen = tunnel->hlen + len;
528
529 dev->needed_headroom = dev->needed_headroom + len;
530 if (set_mtu)
531 dev->mtu = max_t(int, dev->mtu - len, 68);
532
533 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
534 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
535 tunnel->encap.type == TUNNEL_ENCAP_NONE) {
536 dev->features |= NETIF_F_GSO_SOFTWARE;
537 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
538 } else {
539 dev->features &= ~NETIF_F_GSO_SOFTWARE;
540 dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
541 }
542 dev->features |= NETIF_F_LLTX;
543 } else {
544 dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
545 dev->features &= ~(NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE);
546 }
547}
548
549static int ipgre_tunnel_ioctl(struct net_device *dev,
550 struct ifreq *ifr, int cmd)
551{
552 struct ip_tunnel_parm p;
553 int err;
554
555 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
556 return -EFAULT;
557
558 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
559 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
560 p.iph.ihl != 5 || (p.iph.frag_off & htons(~IP_DF)) ||
561 ((p.i_flags | p.o_flags) & (GRE_VERSION | GRE_ROUTING)))
562 return -EINVAL;
563 }
564
565 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
566 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
567
568 err = ip_tunnel_ioctl(dev, &p, cmd);
569 if (err)
570 return err;
571
572 if (cmd == SIOCCHGTUNNEL) {
573 struct ip_tunnel *t = netdev_priv(dev);
574
575 t->parms.i_flags = p.i_flags;
576 t->parms.o_flags = p.o_flags;
577
578 if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
579 ipgre_link_update(dev, true);
580 }
581
582 p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
583 p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);
584
585 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
586 return -EFAULT;
587
588 return 0;
589}
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
619 unsigned short type,
620 const void *daddr, const void *saddr, unsigned int len)
621{
622 struct ip_tunnel *t = netdev_priv(dev);
623 struct iphdr *iph;
624 struct gre_base_hdr *greh;
625
626 iph = skb_push(skb, t->hlen + sizeof(*iph));
627 greh = (struct gre_base_hdr *)(iph+1);
628 greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
629 greh->protocol = htons(type);
630
631 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
632
633
634 if (saddr)
635 memcpy(&iph->saddr, saddr, 4);
636 if (daddr)
637 memcpy(&iph->daddr, daddr, 4);
638 if (iph->daddr)
639 return t->hlen + sizeof(*iph);
640
641 return -(t->hlen + sizeof(*iph));
642}
643
644static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
645{
646 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
647 memcpy(haddr, &iph->saddr, 4);
648 return 4;
649}
650
651static const struct header_ops ipgre_header_ops = {
652 .create = ipgre_header,
653 .parse = ipgre_header_parse,
654};
655
656#ifdef CONFIG_NET_IPGRE_BROADCAST
657static int ipgre_open(struct net_device *dev)
658{
659 struct ip_tunnel *t = netdev_priv(dev);
660
661 if (ipv4_is_multicast(t->parms.iph.daddr)) {
662 struct flowi4 fl4;
663 struct rtable *rt;
664
665 rt = ip_route_output_gre(t->net, &fl4,
666 t->parms.iph.daddr,
667 t->parms.iph.saddr,
668 t->parms.o_key,
669 RT_TOS(t->parms.iph.tos),
670 t->parms.link);
671 if (IS_ERR(rt))
672 return -EADDRNOTAVAIL;
673 dev = rt->dst.dev;
674 ip_rt_put(rt);
675 if (__in_dev_get_rtnl(dev) == NULL)
676 return -EADDRNOTAVAIL;
677 t->mlink = dev->ifindex;
678 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
679 }
680 return 0;
681}
682
683static int ipgre_close(struct net_device *dev)
684{
685 struct ip_tunnel *t = netdev_priv(dev);
686
687 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
688 struct in_device *in_dev;
689 in_dev = inetdev_by_index(t->net, t->mlink);
690 if (in_dev)
691 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
692 }
693 return 0;
694}
695#endif
696
697static const struct net_device_ops ipgre_netdev_ops = {
698 .ndo_init = ipgre_tunnel_init,
699 .ndo_uninit = ip_tunnel_uninit,
700#ifdef CONFIG_NET_IPGRE_BROADCAST
701 .ndo_open = ipgre_open,
702 .ndo_stop = ipgre_close,
703#endif
704 .ndo_start_xmit = ipgre_xmit,
705 .ndo_do_ioctl = ipgre_tunnel_ioctl,
706 .ndo_change_mtu_rh74 = ip_tunnel_change_mtu,
707 .ndo_get_stats64 = ip_tunnel_get_stats64,
708 .ndo_get_iflink = ip_tunnel_get_iflink,
709};
710
711#define GRE_FEATURES (NETIF_F_SG | \
712 NETIF_F_FRAGLIST | \
713 NETIF_F_HIGHDMA | \
714 NETIF_F_HW_CSUM)
715
716static void ipgre_tunnel_setup(struct net_device *dev)
717{
718 dev->netdev_ops = &ipgre_netdev_ops;
719 dev->type = ARPHRD_IPGRE;
720 ip_tunnel_setup(dev, ipgre_net_id);
721}
722
723static void __gre_tunnel_init(struct net_device *dev)
724{
725 struct ip_tunnel *tunnel;
726 int t_hlen;
727
728 tunnel = netdev_priv(dev);
729 tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
730 tunnel->parms.iph.protocol = IPPROTO_GRE;
731
732 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
733
734 t_hlen = tunnel->hlen + sizeof(struct iphdr);
735
736 dev->features |= GRE_FEATURES;
737 dev->hw_features |= GRE_FEATURES;
738
739 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
740
741 dev->features |= NETIF_F_GSO_SOFTWARE;
742 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
743
744
745
746 dev->features |= NETIF_F_LLTX;
747 }
748}
749
750static int ipgre_tunnel_init(struct net_device *dev)
751{
752 struct ip_tunnel *tunnel = netdev_priv(dev);
753 struct iphdr *iph = &tunnel->parms.iph;
754
755 __gre_tunnel_init(dev);
756
757 memcpy(dev->dev_addr, &iph->saddr, 4);
758 memcpy(dev->broadcast, &iph->daddr, 4);
759
760 dev->flags = IFF_NOARP;
761 netif_keep_dst(dev);
762 dev->addr_len = 4;
763
764 if (iph->daddr && !tunnel->collect_md) {
765#ifdef CONFIG_NET_IPGRE_BROADCAST
766 if (ipv4_is_multicast(iph->daddr)) {
767 if (!iph->saddr)
768 return -EINVAL;
769 dev->flags = IFF_BROADCAST;
770 dev->header_ops = &ipgre_header_ops;
771 }
772#endif
773 } else if (!tunnel->collect_md) {
774 dev->header_ops = &ipgre_header_ops;
775 }
776
777 return ip_tunnel_init(dev);
778}
779
780static const struct gre_protocol ipgre_protocol = {
781 .handler = gre_rcv,
782 .err_handler = gre_err,
783};
784
785static int __net_init ipgre_init_net(struct net *net)
786{
787 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
788}
789
790static void __net_exit ipgre_exit_net(struct net *net)
791{
792 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
793 ip_tunnel_delete_net(itn, &ipgre_link_ops);
794}
795
796static struct pernet_operations ipgre_net_ops = {
797 .init = ipgre_init_net,
798 .exit = ipgre_exit_net,
799 .id = &ipgre_net_id,
800 .size = sizeof(struct ip_tunnel_net),
801};
802
803static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
804{
805 __be16 flags;
806
807 if (!data)
808 return 0;
809
810 flags = 0;
811 if (data[IFLA_GRE_IFLAGS])
812 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
813 if (data[IFLA_GRE_OFLAGS])
814 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
815 if (flags & (GRE_VERSION|GRE_ROUTING))
816 return -EINVAL;
817
818 if (data[IFLA_GRE_COLLECT_METADATA] &&
819 data[IFLA_GRE_ENCAP_TYPE] &&
820 nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
821 return -EINVAL;
822
823 return 0;
824}
825
826static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
827{
828 __be32 daddr;
829
830 if (tb[IFLA_ADDRESS]) {
831 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
832 return -EINVAL;
833 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
834 return -EADDRNOTAVAIL;
835 }
836
837 if (!data)
838 goto out;
839
840 if (data[IFLA_GRE_REMOTE]) {
841 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
842 if (!daddr)
843 return -EINVAL;
844 }
845
846out:
847 return ipgre_tunnel_validate(tb, data);
848}
849
850static int ipgre_netlink_parms(struct net_device *dev,
851 struct nlattr *data[],
852 struct nlattr *tb[],
853 struct ip_tunnel_parm *parms)
854{
855 struct ip_tunnel *t = netdev_priv(dev);
856
857 memset(parms, 0, sizeof(*parms));
858
859 parms->iph.protocol = IPPROTO_GRE;
860
861 if (!data)
862 return 0;
863
864 if (data[IFLA_GRE_LINK])
865 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
866
867 if (data[IFLA_GRE_IFLAGS])
868 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
869
870 if (data[IFLA_GRE_OFLAGS])
871 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
872
873 if (data[IFLA_GRE_IKEY])
874 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
875
876 if (data[IFLA_GRE_OKEY])
877 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
878
879 if (data[IFLA_GRE_LOCAL])
880 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
881
882 if (data[IFLA_GRE_REMOTE])
883 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
884
885 if (data[IFLA_GRE_TTL])
886 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
887
888 if (data[IFLA_GRE_TOS])
889 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
890
891 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
892 if (t->ignore_df)
893 return -EINVAL;
894 parms->iph.frag_off = htons(IP_DF);
895 }
896
897 if (data[IFLA_GRE_COLLECT_METADATA]) {
898 t->collect_md = true;
899 if (dev->type == ARPHRD_IPGRE)
900 dev->type = ARPHRD_NONE;
901 }
902
903 if (data[IFLA_GRE_IGNORE_DF]) {
904 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
905 && (parms->iph.frag_off & htons(IP_DF)))
906 return -EINVAL;
907 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
908 }
909
910 return 0;
911}
912
913
914static bool ipgre_netlink_encap_parms(struct nlattr *data[],
915 struct ip_tunnel_encap *ipencap)
916{
917 bool ret = false;
918
919 memset(ipencap, 0, sizeof(*ipencap));
920
921 if (!data)
922 return ret;
923
924 if (data[IFLA_GRE_ENCAP_TYPE]) {
925 ret = true;
926 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
927 }
928
929 if (data[IFLA_GRE_ENCAP_FLAGS]) {
930 ret = true;
931 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
932 }
933
934 if (data[IFLA_GRE_ENCAP_SPORT]) {
935 ret = true;
936 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
937 }
938
939 if (data[IFLA_GRE_ENCAP_DPORT]) {
940 ret = true;
941 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
942 }
943
944 return ret;
945}
946
947static int gre_tap_init(struct net_device *dev)
948{
949 __gre_tunnel_init(dev);
950 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
951 netif_keep_dst(dev);
952
953 return ip_tunnel_init(dev);
954}
955
956static const struct net_device_ops gre_tap_netdev_ops = {
957 .ndo_init = gre_tap_init,
958 .ndo_uninit = ip_tunnel_uninit,
959 .ndo_start_xmit = gre_tap_xmit,
960 .ndo_set_mac_address = eth_mac_addr,
961 .ndo_validate_addr = eth_validate_addr,
962 .ndo_change_mtu_rh74 = ip_tunnel_change_mtu,
963 .ndo_get_stats64 = ip_tunnel_get_stats64,
964 .ndo_get_iflink = ip_tunnel_get_iflink,
965 .ndo_fill_metadata_dst = gre_fill_metadata_dst,
966};
967
968static void ipgre_tap_setup(struct net_device *dev)
969{
970 ether_setup(dev);
971 dev->netdev_ops = &gre_tap_netdev_ops;
972 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
973 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
974 ip_tunnel_setup(dev, gre_tap_net_id);
975}
976
977static int ipgre_newlink(struct net *src_net, struct net_device *dev,
978 struct nlattr *tb[], struct nlattr *data[])
979{
980 struct ip_tunnel_parm p;
981 struct ip_tunnel_encap ipencap;
982 int err;
983
984 if (ipgre_netlink_encap_parms(data, &ipencap)) {
985 struct ip_tunnel *t = netdev_priv(dev);
986 err = ip_tunnel_encap_setup(t, &ipencap);
987
988 if (err < 0)
989 return err;
990 }
991
992 err = ipgre_netlink_parms(dev, data, tb, &p);
993 if (err < 0)
994 return err;
995 return ip_tunnel_newlink(dev, tb, &p);
996}
997
998static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
999 struct nlattr *data[])
1000{
1001 struct ip_tunnel *t = netdev_priv(dev);
1002 struct ip_tunnel_encap ipencap;
1003 struct ip_tunnel_parm p;
1004 int err;
1005
1006 if (ipgre_netlink_encap_parms(data, &ipencap)) {
1007 err = ip_tunnel_encap_setup(t, &ipencap);
1008
1009 if (err < 0)
1010 return err;
1011 }
1012
1013 err = ipgre_netlink_parms(dev, data, tb, &p);
1014 if (err < 0)
1015 return err;
1016
1017 err = ip_tunnel_changelink(dev, tb, &p);
1018 if (err < 0)
1019 return err;
1020
1021 t->parms.i_flags = p.i_flags;
1022 t->parms.o_flags = p.o_flags;
1023
1024 if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
1025 ipgre_link_update(dev, !tb[IFLA_MTU]);
1026
1027 return 0;
1028}
1029
1030static size_t ipgre_get_size(const struct net_device *dev)
1031{
1032 return
1033
1034 nla_total_size(4) +
1035
1036 nla_total_size(2) +
1037
1038 nla_total_size(2) +
1039
1040 nla_total_size(4) +
1041
1042 nla_total_size(4) +
1043
1044 nla_total_size(4) +
1045
1046 nla_total_size(4) +
1047
1048 nla_total_size(1) +
1049
1050 nla_total_size(1) +
1051
1052 nla_total_size(1) +
1053
1054 nla_total_size(2) +
1055
1056 nla_total_size(2) +
1057
1058 nla_total_size(2) +
1059
1060 nla_total_size(2) +
1061
1062 nla_total_size(0) +
1063
1064 nla_total_size(1) +
1065 0;
1066}
1067
1068static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1069{
1070 struct ip_tunnel *t = netdev_priv(dev);
1071 struct ip_tunnel_parm *p = &t->parms;
1072
1073 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1074 nla_put_be16(skb, IFLA_GRE_IFLAGS,
1075 gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1076 nla_put_be16(skb, IFLA_GRE_OFLAGS,
1077 gre_tnl_flags_to_gre_flags(p->o_flags)) ||
1078 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1079 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1080 nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1081 nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1082 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1083 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1084 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1085 !!(p->iph.frag_off & htons(IP_DF))))
1086 goto nla_put_failure;
1087
1088 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1089 t->encap.type) ||
1090 nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1091 t->encap.sport) ||
1092 nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1093 t->encap.dport) ||
1094 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1095 t->encap.flags))
1096 goto nla_put_failure;
1097
1098 if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1099 goto nla_put_failure;
1100
1101 if (t->collect_md) {
1102 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1103 goto nla_put_failure;
1104 }
1105
1106 return 0;
1107
1108nla_put_failure:
1109 return -EMSGSIZE;
1110}
1111
1112static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1113 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1114 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1115 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1116 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1117 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
1118 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1119 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
1120 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1121 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1122 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
1123 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
1124 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
1125 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
1126 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
1127 [IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG },
1128 [IFLA_GRE_IGNORE_DF] = { .type = NLA_U8 },
1129};
1130
1131static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1132 .kind = "gre",
1133 .maxtype = IFLA_GRE_MAX,
1134 .policy = ipgre_policy,
1135 .priv_size = sizeof(struct ip_tunnel),
1136 .setup = ipgre_tunnel_setup,
1137 .validate = ipgre_tunnel_validate,
1138 .newlink = ipgre_newlink,
1139 .changelink = ipgre_changelink,
1140 .dellink = ip_tunnel_dellink,
1141 .get_size = ipgre_get_size,
1142 .fill_info = ipgre_fill_info,
1143 .get_link_net = ip_tunnel_get_link_net,
1144};
1145
1146static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1147 .kind = "gretap",
1148 .maxtype = IFLA_GRE_MAX,
1149 .policy = ipgre_policy,
1150 .priv_size = sizeof(struct ip_tunnel),
1151 .setup = ipgre_tap_setup,
1152 .validate = ipgre_tap_validate,
1153 .newlink = ipgre_newlink,
1154 .changelink = ipgre_changelink,
1155 .dellink = ip_tunnel_dellink,
1156 .get_size = ipgre_get_size,
1157 .fill_info = ipgre_fill_info,
1158 .get_link_net = ip_tunnel_get_link_net,
1159};
1160
1161struct net_device *gretap_fb_dev_create(struct net *net, const char *name)
1162{
1163 struct nlattr *tb[IFLA_MAX + 1];
1164 struct net_device *dev;
1165 LIST_HEAD(list_kill);
1166 struct ip_tunnel *t;
1167 int err;
1168
1169 memset(&tb, 0, sizeof(tb));
1170
1171 dev = rtnl_create_link(net, name,
1172 &ipgre_tap_ops, tb);
1173 if (IS_ERR(dev))
1174 return dev;
1175
1176
1177 t = netdev_priv(dev);
1178 t->collect_md = true;
1179
1180 err = ipgre_newlink(net, dev, tb, NULL);
1181 if (err < 0) {
1182 free_netdev(dev);
1183 return ERR_PTR(err);
1184 }
1185
1186
1187
1188
1189 err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1190 if (err)
1191 goto out;
1192
1193 err = rtnl_configure_link(dev, NULL);
1194 if (err < 0)
1195 goto out;
1196
1197 return dev;
1198out:
1199 ip_tunnel_dellink(dev, &list_kill);
1200 unregister_netdevice_many(&list_kill);
1201 return ERR_PTR(err);
1202}
1203EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1204
1205static int __net_init ipgre_tap_init_net(struct net *net)
1206{
1207 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1208}
1209
1210static void __net_exit ipgre_tap_exit_net(struct net *net)
1211{
1212 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
1213 ip_tunnel_delete_net(itn, &ipgre_tap_ops);
1214}
1215
1216static struct pernet_operations ipgre_tap_net_ops = {
1217 .init = ipgre_tap_init_net,
1218 .exit = ipgre_tap_exit_net,
1219 .id = &gre_tap_net_id,
1220 .size = sizeof(struct ip_tunnel_net),
1221};
1222
1223static int __init ipgre_init(void)
1224{
1225 int err;
1226
1227 pr_info("GRE over IPv4 tunneling driver\n");
1228
1229 err = register_pernet_device(&ipgre_net_ops);
1230 if (err < 0)
1231 return err;
1232
1233 err = register_pernet_device(&ipgre_tap_net_ops);
1234 if (err < 0)
1235 goto pnet_tap_faied;
1236
1237 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1238 if (err < 0) {
1239 pr_info("%s: can't add protocol\n", __func__);
1240 goto add_proto_failed;
1241 }
1242
1243 err = rtnl_link_register(&ipgre_link_ops);
1244 if (err < 0)
1245 goto rtnl_link_failed;
1246
1247 err = rtnl_link_register(&ipgre_tap_ops);
1248 if (err < 0)
1249 goto tap_ops_failed;
1250
1251 return 0;
1252
1253tap_ops_failed:
1254 rtnl_link_unregister(&ipgre_link_ops);
1255rtnl_link_failed:
1256 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1257add_proto_failed:
1258 unregister_pernet_device(&ipgre_tap_net_ops);
1259pnet_tap_faied:
1260 unregister_pernet_device(&ipgre_net_ops);
1261 return err;
1262}
1263
1264static void __exit ipgre_fini(void)
1265{
1266 rtnl_link_unregister(&ipgre_tap_ops);
1267 rtnl_link_unregister(&ipgre_link_ops);
1268 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1269 unregister_pernet_device(&ipgre_tap_net_ops);
1270 unregister_pernet_device(&ipgre_net_ops);
1271}
1272
1273module_init(ipgre_init);
1274module_exit(ipgre_fini);
1275MODULE_LICENSE("GPL");
1276MODULE_ALIAS_RTNL_LINK("gre");
1277MODULE_ALIAS_RTNL_LINK("gretap");
1278MODULE_ALIAS_NETDEV("gre0");
1279MODULE_ALIAS_NETDEV("gretap0");
1280
