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