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