drivers: net cpsw: Enable In Band mode in cpsw for 10 mbps
[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                 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 + sizeof(*iph);
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, &ipgre_link_ops);
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, &ipgre_tap_ops);
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");