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