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