net/ipv4/ip_gre.c

   1 /*
   2  *      Linux NET3:     GRE over IP protocol decoder.
   3  *
   4  *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License
   8  *      as published by the Free Software Foundation; either version
   9  *      2 of the License, or (at your option) any later version.
  10  *
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/capability.h>
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/slab.h>
  20 #include <asm/uaccess.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/in.h>
  24 #include <linux/tcp.h>
  25 #include <linux/udp.h>
  26 #include <linux/if_arp.h>
  27 #include <linux/mroute.h>
  28 #include <linux/init.h>
  29 #include <linux/in6.h>
  30 #include <linux/inetdevice.h>
  31 #include <linux/igmp.h>
  32 #include <linux/netfilter_ipv4.h>
  33 #include <linux/etherdevice.h>
  34 #include <linux/if_ether.h>
  35
  36 #include <net/sock.h>
  37 #include <net/ip.h>
  38 #include <net/icmp.h>
  39 #include <net/protocol.h>
  40 #include <net/ip_tunnels.h>
  41 #include <net/arp.h>
  42 #include <net/checksum.h>
  43 #include <net/dsfield.h>
  44 #include <net/inet_ecn.h>
  45 #include <net/xfrm.h>
  46 #include <net/net_namespace.h>
  47 #include <net/netns/generic.h>
  48 #include <net/rtnetlink.h>
  49 #include <net/gre.h>
  50
  51 #if IS_ENABLED(CONFIG_IPV6)
  52 #include <net/ipv6.h>
  53 #include <net/ip6_fib.h>
  54 #include <net/ip6_route.h>
  55 #endif
  56
  57 /*
  58    Problems & solutions
  59    --------------------
  60
  61    1. The most important issue is detecting local dead loops.
  62    They would cause complete host lockup in transmit, which
  63    would be "resolved" by stack overflow or, if queueing is enabled,
  64    with infinite looping in net_bh.
  65
  66    We cannot track such dead loops during route installation,
  67    it is infeasible task. The most general solutions would be
  68    to keep skb->encapsulation counter (sort of local ttl),
  69    and silently drop packet when it expires. It is a good
  70    solution, but it supposes maintaining new variable in ALL
  71    skb, even if no tunneling is used.
  72
  73    Current solution: xmit_recursion breaks dead loops. This is a percpu
  74    counter, since when we enter the first ndo_xmit(), cpu migration is
  75    forbidden. We force an exit if this counter reaches RECURSION_LIMIT
  76
  77    2. Networking dead loops would not kill routers, but would really
  78    kill network. IP hop limit plays role of "t->recursion" in this case,
  79    if we copy it from packet being encapsulated to upper header.
  80    It is very good solution, but it introduces two problems:
  81
  82    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
  83      do not work over tunnels.
  84    - traceroute does not work. I planned to relay ICMP from tunnel,
  85      so that this problem would be solved and traceroute output
  86      would even more informative. This idea appeared to be wrong:
  87      only Linux complies to rfc1812 now (yes, guys, Linux is the only
  88      true router now :-)), all routers (at least, in neighbourhood of mine)
  89      return only 8 bytes of payload. It is the end.
  90
  91    Hence, if we want that OSPF worked or traceroute said something reasonable,
  92    we should search for another solution.
  93
  94    One of them is to parse packet trying to detect inner encapsulation
  95    made by our node. It is difficult or even impossible, especially,
  96    taking into account fragmentation. TO be short, ttl is not solution at all.
  97
  98    Current solution: The solution was UNEXPECTEDLY SIMPLE.
  99    We force DF flag on tunnels with preconfigured hop limit,
 100    that is ALL. :-) Well, it does not remove the problem completely,
 101    but exponential growth of network traffic is changed to linear
 102    (branches, that exceed pmtu are pruned) and tunnel mtu
 103    rapidly degrades to value <68, where looping stops.
 104    Yes, it is not good if there exists a router in the loop,
 105    which does not force DF, even when encapsulating packets have DF set.
 106    But it is not our problem! Nobody could accuse us, we made
 107    all that we could make. Even if it is your gated who injected
 108    fatal route to network, even if it were you who configured
 109    fatal static route: you are innocent. :-)
 110
 111    Alexey Kuznetsov.
 112  */
 113
 114 static bool log_ecn_error = true;
 115 module_param(log_ecn_error, bool, 0644);
 116 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 117
 118 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
 119 static int ipgre_tunnel_init(struct net_device *dev);
 120
 121 static int ipgre_net_id __read_mostly;
 122 static int gre_tap_net_id __read_mostly;
 123
 124 static int ipgre_err(struct sk_buff *skb, u32 info,
 125                      const struct tnl_ptk_info *tpi)
 126 {
 127
 128         /* All the routers (except for Linux) return only
 129            8 bytes of packet payload. It means, that precise relaying of
 130            ICMP in the real Internet is absolutely infeasible.
 131
 132            Moreover, Cisco "wise men" put GRE key to the third word
 133            in GRE header. It makes impossible maintaining even soft
 134            state for keyed GRE tunnels with enabled checksum. Tell
 135            them "thank you".
 136
 137            Well, I wonder, rfc1812 was written by Cisco employee,
 138            what the hell these idiots break standards established
 139            by themselves???
 140            */
 141         struct net *net = dev_net(skb->dev);
 142         struct ip_tunnel_net *itn;
 143         const struct iphdr *iph;
 144         const int type = icmp_hdr(skb)->type;
 145         const int code = icmp_hdr(skb)->code;
 146         struct ip_tunnel *t;
 147
 148         switch (type) {
 149         default:
 150         case ICMP_PARAMETERPROB:
 151                 return PACKET_RCVD;
 152
 153         case ICMP_DEST_UNREACH:
 154                 switch (code) {
 155                 case ICMP_SR_FAILED:
 156                 case ICMP_PORT_UNREACH:
 157                         /* Impossible event. */
 158                         return PACKET_RCVD;
 159                 default:
 160                         /* All others are translated to HOST_UNREACH.
 161                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 162                            I believe they are just ether pollution. --ANK
 163                          */
 164                         break;
 165                 }
 166                 break;
 167         case ICMP_TIME_EXCEEDED:
 168                 if (code != ICMP_EXC_TTL)
 169                         return PACKET_RCVD;
 170                 break;
 171
 172         case ICMP_REDIRECT:
 173                 break;
 174         }
 175
 176         if (tpi->proto == htons(ETH_P_TEB))
 177                 itn = net_generic(net, gre_tap_net_id);
 178         else
 179                 itn = net_generic(net, ipgre_net_id);
 180
 181         iph = (const struct iphdr *)skb->data;
 182         t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 183                              iph->daddr, iph->saddr, tpi->key);
 184
 185         if (t == NULL)
 186                 return PACKET_REJECT;
 187
 188         if (t->parms.iph.daddr == 0 ||
 189             ipv4_is_multicast(t->parms.iph.daddr))
 190                 return PACKET_RCVD;
 191
 192         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 193                 return PACKET_RCVD;
 194
 195         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 196                 t->err_count++;
 197         else
 198                 t->err_count = 1;
 199         t->err_time = jiffies;
 200         return PACKET_RCVD;
 201 }
 202
 203 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
 204 {
 205         struct net *net = dev_net(skb->dev);
 206         struct ip_tunnel_net *itn;
 207         const struct iphdr *iph;
 208         struct ip_tunnel *tunnel;
 209
 210         if (tpi->proto == htons(ETH_P_TEB))
 211                 itn = net_generic(net, gre_tap_net_id);
 212         else
 213                 itn = net_generic(net, ipgre_net_id);
 214
 215         iph = ip_hdr(skb);
 216         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 217                                   iph->saddr, iph->daddr, tpi->key);
 218
 219         if (tunnel) {
 220                 ip_tunnel_rcv(tunnel, skb, tpi, log_ecn_error);
 221                 return PACKET_RCVD;
 222         }
 223         return PACKET_REJECT;
 224 }
 225
 226 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
 227                        const struct iphdr *tnl_params,
 228                        __be16 proto)
 229 {
 230         struct ip_tunnel *tunnel = netdev_priv(dev);
 231         struct tnl_ptk_info tpi;
 232
 233         tpi.flags = tunnel->parms.o_flags;
 234         tpi.proto = proto;
 235         tpi.key = tunnel->parms.o_key;
 236         if (tunnel->parms.o_flags & TUNNEL_SEQ)
 237                 tunnel->o_seqno++;
 238         tpi.seq = htonl(tunnel->o_seqno);
 239
 240         /* Push GRE header. */
 241         gre_build_header(skb, &tpi, tunnel->hlen);
 242
 243         ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
 244 }
 245
 246 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
 247                               struct net_device *dev)
 248 {
 249         struct ip_tunnel *tunnel = netdev_priv(dev);
 250         const struct iphdr *tnl_params;
 251
 252         skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
 253         if (IS_ERR(skb))
 254                 goto out;
 255
 256         if (dev->header_ops) {
 257                 /* Need space for new headers */
 258                 if (skb_cow_head(skb, dev->needed_headroom -
 259                                       (tunnel->hlen + sizeof(struct iphdr))))
 260                         goto free_skb;
 261
 262                 tnl_params = (const struct iphdr *)skb->data;
 263
 264                 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
 265                  * to gre header.
 266                  */
 267                 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
 268         } else {
 269                 if (skb_cow_head(skb, dev->needed_headroom))
 270                         goto free_skb;
 271
 272                 tnl_params = &tunnel->parms.iph;
 273         }
 274
 275         __gre_xmit(skb, dev, tnl_params, skb->protocol);
 276
 277         return NETDEV_TX_OK;
 278
 279 free_skb:
 280         dev_kfree_skb(skb);
 281 out:
 282         dev->stats.tx_dropped++;
 283         return NETDEV_TX_OK;
 284 }
 285
 286 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
 287                                 struct net_device *dev)
 288 {
 289         struct ip_tunnel *tunnel = netdev_priv(dev);
 290
 291         skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
 292         if (IS_ERR(skb))
 293                 goto out;
 294
 295         if (skb_cow_head(skb, dev->needed_headroom))
 296                 goto free_skb;
 297
 298         __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
 299
 300         return NETDEV_TX_OK;
 301
 302 free_skb:
 303         dev_kfree_skb(skb);
 304 out:
 305         dev->stats.tx_dropped++;
 306         return NETDEV_TX_OK;
 307 }
 308
 309 static int ipgre_tunnel_ioctl(struct net_device *dev,
 310                               struct ifreq *ifr, int cmd)
 311 {
 312         int err = 0;
 313         struct ip_tunnel_parm p;
 314
 315         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 316                 return -EFAULT;
 317         if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
 318             p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
 319             ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))) {
 320                 return -EINVAL;
 321         }
 322         p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
 323         p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
 324
 325         err = ip_tunnel_ioctl(dev, &p, cmd);
 326         if (err)
 327                 return err;
 328
 329         p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
 330         p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
 331
 332         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 333                 return -EFAULT;
 334         return 0;
 335 }
 336
 337 /* Nice toy. Unfortunately, useless in real life :-)
 338    It allows to construct virtual multiprotocol broadcast "LAN"
 339    over the Internet, provided multicast routing is tuned.
 340
 341
 342    I have no idea was this bicycle invented before me,
 343    so that I had to set ARPHRD_IPGRE to a random value.
 344    I have an impression, that Cisco could make something similar,
 345    but this feature is apparently missing in IOS<=11.2(8).
 346
 347    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
 348    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
 349
 350    ping -t 255 224.66.66.66
 351
 352    If nobody answers, mbone does not work.
 353
 354    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
 355    ip addr add 10.66.66.<somewhat>/24 dev Universe
 356    ifconfig Universe up
 357    ifconfig Universe add fe80::<Your_real_addr>/10
 358    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
 359    ftp 10.66.66.66
 360    ...
 361    ftp fec0:6666:6666::193.233.7.65
 362    ...
 363  */
 364 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
 365                         unsigned short type,
 366                         const void *daddr, const void *saddr, unsigned int len)
 367 {
 368         struct ip_tunnel *t = netdev_priv(dev);
 369         struct iphdr *iph;
 370         struct gre_base_hdr *greh;
 371
 372         iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
 373         greh = (struct gre_base_hdr *)(iph+1);
 374         greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
 375         greh->protocol = htons(type);
 376
 377         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 378
 379         /* Set the source hardware address. */
 380         if (saddr)
 381                 memcpy(&iph->saddr, saddr, 4);
 382         if (daddr)
 383                 memcpy(&iph->daddr, daddr, 4);
 384         if (iph->daddr)
 385                 return t->hlen;
 386
 387         return -(t->hlen + sizeof(*iph));
 388 }
 389
 390 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 391 {
 392         const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
 393         memcpy(haddr, &iph->saddr, 4);
 394         return 4;
 395 }
 396
 397 static const struct header_ops ipgre_header_ops = {
 398         .create = ipgre_header,
 399         .parse  = ipgre_header_parse,
 400 };
 401
 402 #ifdef CONFIG_NET_IPGRE_BROADCAST
 403 static int ipgre_open(struct net_device *dev)
 404 {
 405         struct ip_tunnel *t = netdev_priv(dev);
 406
 407         if (ipv4_is_multicast(t->parms.iph.daddr)) {
 408                 struct flowi4 fl4;
 409                 struct rtable *rt;
 410
 411                 rt = ip_route_output_gre(dev_net(dev), &fl4,
 412                                          t->parms.iph.daddr,
 413                                          t->parms.iph.saddr,
 414                                          t->parms.o_key,
 415                                          RT_TOS(t->parms.iph.tos),
 416                                          t->parms.link);
 417                 if (IS_ERR(rt))
 418                         return -EADDRNOTAVAIL;
 419                 dev = rt->dst.dev;
 420                 ip_rt_put(rt);
 421                 if (__in_dev_get_rtnl(dev) == NULL)
 422                         return -EADDRNOTAVAIL;
 423                 t->mlink = dev->ifindex;
 424                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 425         }
 426         return 0;
 427 }
 428
 429 static int ipgre_close(struct net_device *dev)
 430 {
 431         struct ip_tunnel *t = netdev_priv(dev);
 432
 433         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
 434                 struct in_device *in_dev;
 435                 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
 436                 if (in_dev)
 437                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 438         }
 439         return 0;
 440 }
 441 #endif
 442
 443 static const struct net_device_ops ipgre_netdev_ops = {
 444         .ndo_init               = ipgre_tunnel_init,
 445         .ndo_uninit             = ip_tunnel_uninit,
 446 #ifdef CONFIG_NET_IPGRE_BROADCAST
 447         .ndo_open               = ipgre_open,
 448         .ndo_stop               = ipgre_close,
 449 #endif
 450         .ndo_start_xmit         = ipgre_xmit,
 451         .ndo_do_ioctl           = ipgre_tunnel_ioctl,
 452         .ndo_change_mtu         = ip_tunnel_change_mtu,
 453         .ndo_get_stats64        = ip_tunnel_get_stats64,
 454 };
 455
 456 #define GRE_FEATURES (NETIF_F_SG |              \
 457                       NETIF_F_FRAGLIST |        \
 458                       NETIF_F_HIGHDMA |         \
 459                       NETIF_F_HW_CSUM)
 460
 461 static void ipgre_tunnel_setup(struct net_device *dev)
 462 {
 463         dev->netdev_ops         = &ipgre_netdev_ops;
 464         ip_tunnel_setup(dev, ipgre_net_id);
 465 }
 466
 467 static void __gre_tunnel_init(struct net_device *dev)
 468 {
 469         struct ip_tunnel *tunnel;
 470
 471         tunnel = netdev_priv(dev);
 472         tunnel->hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
 473         tunnel->parms.iph.protocol = IPPROTO_GRE;
 474
 475         dev->needed_headroom    = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
 476         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
 477
 478         dev->features           |= NETIF_F_NETNS_LOCAL | GRE_FEATURES;
 479         dev->hw_features        |= GRE_FEATURES;
 480
 481         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 482                 /* TCP offload with GRE SEQ is not supported. */
 483                 dev->features    |= NETIF_F_GSO_SOFTWARE;
 484                 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 485                 /* Can use a lockless transmit, unless we generate
 486                  * output sequences
 487                  */
 488                 dev->features |= NETIF_F_LLTX;
 489         }
 490 }
 491
 492 static int ipgre_tunnel_init(struct net_device *dev)
 493 {
 494         struct ip_tunnel *tunnel = netdev_priv(dev);
 495         struct iphdr *iph = &tunnel->parms.iph;
 496
 497         __gre_tunnel_init(dev);
 498
 499         memcpy(dev->dev_addr, &iph->saddr, 4);
 500         memcpy(dev->broadcast, &iph->daddr, 4);
 501
 502         dev->type               = ARPHRD_IPGRE;
 503         dev->flags              = IFF_NOARP;
 504         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 505         dev->addr_len           = 4;
 506
 507         if (iph->daddr) {
 508 #ifdef CONFIG_NET_IPGRE_BROADCAST
 509                 if (ipv4_is_multicast(iph->daddr)) {
 510                         if (!iph->saddr)
 511                                 return -EINVAL;
 512                         dev->flags = IFF_BROADCAST;
 513                         dev->header_ops = &ipgre_header_ops;
 514                 }
 515 #endif
 516         } else
 517                 dev->header_ops = &ipgre_header_ops;
 518
 519         return ip_tunnel_init(dev);
 520 }
 521
 522 static struct gre_cisco_protocol ipgre_protocol = {
 523         .handler        = ipgre_rcv,
 524         .err_handler    = ipgre_err,
 525         .priority       = 0,
 526 };
 527
 528 static int __net_init ipgre_init_net(struct net *net)
 529 {
 530         return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
 531 }
 532
 533 static void __net_exit ipgre_exit_net(struct net *net)
 534 {
 535         struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
 536         ip_tunnel_delete_net(itn);
 537 }
 538
 539 static struct pernet_operations ipgre_net_ops = {
 540         .init = ipgre_init_net,
 541         .exit = ipgre_exit_net,
 542         .id   = &ipgre_net_id,
 543         .size = sizeof(struct ip_tunnel_net),
 544 };
 545
 546 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
 547 {
 548         __be16 flags;
 549
 550         if (!data)
 551                 return 0;
 552
 553         flags = 0;
 554         if (data[IFLA_GRE_IFLAGS])
 555                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
 556         if (data[IFLA_GRE_OFLAGS])
 557                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
 558         if (flags & (GRE_VERSION|GRE_ROUTING))
 559                 return -EINVAL;
 560
 561         return 0;
 562 }
 563
 564 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
 565 {
 566         __be32 daddr;
 567
 568         if (tb[IFLA_ADDRESS]) {
 569                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 570                         return -EINVAL;
 571                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 572                         return -EADDRNOTAVAIL;
 573         }
 574
 575         if (!data)
 576                 goto out;
 577
 578         if (data[IFLA_GRE_REMOTE]) {
 579                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
 580                 if (!daddr)
 581                         return -EINVAL;
 582         }
 583
 584 out:
 585         return ipgre_tunnel_validate(tb, data);
 586 }
 587
 588 static void ipgre_netlink_parms(struct nlattr *data[], struct nlattr *tb[],
 589                                struct ip_tunnel_parm *parms)
 590 {
 591         memset(parms, 0, sizeof(*parms));
 592
 593         parms->iph.protocol = IPPROTO_GRE;
 594
 595         if (!data)
 596                 return;
 597
 598         if (data[IFLA_GRE_LINK])
 599                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
 600
 601         if (data[IFLA_GRE_IFLAGS])
 602                 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
 603
 604         if (data[IFLA_GRE_OFLAGS])
 605                 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
 606
 607         if (data[IFLA_GRE_IKEY])
 608                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
 609
 610         if (data[IFLA_GRE_OKEY])
 611                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
 612
 613         if (data[IFLA_GRE_LOCAL])
 614                 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
 615
 616         if (data[IFLA_GRE_REMOTE])
 617                 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
 618
 619         if (data[IFLA_GRE_TTL])
 620                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
 621
 622         if (data[IFLA_GRE_TOS])
 623                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
 624
 625         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
 626                 parms->iph.frag_off = htons(IP_DF);
 627 }
 628
 629 static int gre_tap_init(struct net_device *dev)
 630 {
 631         __gre_tunnel_init(dev);
 632
 633         return ip_tunnel_init(dev);
 634 }
 635
 636 static const struct net_device_ops gre_tap_netdev_ops = {
 637         .ndo_init               = gre_tap_init,
 638         .ndo_uninit             = ip_tunnel_uninit,
 639         .ndo_start_xmit         = gre_tap_xmit,
 640         .ndo_set_mac_address    = eth_mac_addr,
 641         .ndo_validate_addr      = eth_validate_addr,
 642         .ndo_change_mtu         = ip_tunnel_change_mtu,
 643         .ndo_get_stats64        = ip_tunnel_get_stats64,
 644 };
 645
 646 static void ipgre_tap_setup(struct net_device *dev)
 647 {
 648         ether_setup(dev);
 649         dev->netdev_ops         = &gre_tap_netdev_ops;
 650         ip_tunnel_setup(dev, gre_tap_net_id);
 651 }
 652
 653 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
 654                          struct nlattr *tb[], struct nlattr *data[])
 655 {
 656         struct ip_tunnel_parm p;
 657
 658         ipgre_netlink_parms(data, tb, &p);
 659         return ip_tunnel_newlink(dev, tb, &p);
 660 }
 661
 662 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
 663                             struct nlattr *data[])
 664 {
 665         struct ip_tunnel_parm p;
 666
 667         ipgre_netlink_parms(data, tb, &p);
 668         return ip_tunnel_changelink(dev, tb, &p);
 669 }
 670
 671 static size_t ipgre_get_size(const struct net_device *dev)
 672 {
 673         return
 674                 /* IFLA_GRE_LINK */
 675                 nla_total_size(4) +
 676                 /* IFLA_GRE_IFLAGS */
 677                 nla_total_size(2) +
 678                 /* IFLA_GRE_OFLAGS */
 679                 nla_total_size(2) +
 680                 /* IFLA_GRE_IKEY */
 681                 nla_total_size(4) +
 682                 /* IFLA_GRE_OKEY */
 683                 nla_total_size(4) +
 684                 /* IFLA_GRE_LOCAL */
 685                 nla_total_size(4) +
 686                 /* IFLA_GRE_REMOTE */
 687                 nla_total_size(4) +
 688                 /* IFLA_GRE_TTL */
 689                 nla_total_size(1) +
 690                 /* IFLA_GRE_TOS */
 691                 nla_total_size(1) +
 692                 /* IFLA_GRE_PMTUDISC */
 693                 nla_total_size(1) +
 694                 0;
 695 }
 696
 697 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
 698 {
 699         struct ip_tunnel *t = netdev_priv(dev);
 700         struct ip_tunnel_parm *p = &t->parms;
 701
 702         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
 703             nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
 704             nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
 705             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
 706             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
 707             nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
 708             nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
 709             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
 710             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
 711             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
 712                        !!(p->iph.frag_off & htons(IP_DF))))
 713                 goto nla_put_failure;
 714         return 0;
 715
 716 nla_put_failure:
 717         return -EMSGSIZE;
 718 }
 719
 720 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
 721         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
 722         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
 723         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
 724         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
 725         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
 726         [IFLA_GRE_LOCAL]        = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
 727         [IFLA_GRE_REMOTE]       = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
 728         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
 729         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
 730         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
 731 };
 732
 733 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
 734         .kind           = "gre",
 735         .maxtype        = IFLA_GRE_MAX,
 736         .policy         = ipgre_policy,
 737         .priv_size      = sizeof(struct ip_tunnel),
 738         .setup          = ipgre_tunnel_setup,
 739         .validate       = ipgre_tunnel_validate,
 740         .newlink        = ipgre_newlink,
 741         .changelink     = ipgre_changelink,
 742         .dellink        = ip_tunnel_dellink,
 743         .get_size       = ipgre_get_size,
 744         .fill_info      = ipgre_fill_info,
 745 };
 746
 747 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
 748         .kind           = "gretap",
 749         .maxtype        = IFLA_GRE_MAX,
 750         .policy         = ipgre_policy,
 751         .priv_size      = sizeof(struct ip_tunnel),
 752         .setup          = ipgre_tap_setup,
 753         .validate       = ipgre_tap_validate,
 754         .newlink        = ipgre_newlink,
 755         .changelink     = ipgre_changelink,
 756         .dellink        = ip_tunnel_dellink,
 757         .get_size       = ipgre_get_size,
 758         .fill_info      = ipgre_fill_info,
 759 };
 760
 761 static int __net_init ipgre_tap_init_net(struct net *net)
 762 {
 763         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, NULL);
 764 }
 765
 766 static void __net_exit ipgre_tap_exit_net(struct net *net)
 767 {
 768         struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
 769         ip_tunnel_delete_net(itn);
 770 }
 771
 772 static struct pernet_operations ipgre_tap_net_ops = {
 773         .init = ipgre_tap_init_net,
 774         .exit = ipgre_tap_exit_net,
 775         .id   = &gre_tap_net_id,
 776         .size = sizeof(struct ip_tunnel_net),
 777 };
 778
 779 static int __init ipgre_init(void)
 780 {
 781         int err;
 782
 783         pr_info("GRE over IPv4 tunneling driver\n");
 784
 785         err = register_pernet_device(&ipgre_net_ops);
 786         if (err < 0)
 787                 return err;
 788
 789         err = register_pernet_device(&ipgre_tap_net_ops);
 790         if (err < 0)
 791                 goto pnet_tap_faied;
 792
 793         err = gre_cisco_register(&ipgre_protocol);
 794         if (err < 0) {
 795                 pr_info("%s: can't add protocol\n", __func__);
 796                 goto add_proto_failed;
 797         }
 798
 799         err = rtnl_link_register(&ipgre_link_ops);
 800         if (err < 0)
 801                 goto rtnl_link_failed;
 802
 803         err = rtnl_link_register(&ipgre_tap_ops);
 804         if (err < 0)
 805                 goto tap_ops_failed;
 806
 807         return 0;
 808
 809 tap_ops_failed:
 810         rtnl_link_unregister(&ipgre_link_ops);
 811 rtnl_link_failed:
 812         gre_cisco_unregister(&ipgre_protocol);
 813 add_proto_failed:
 814         unregister_pernet_device(&ipgre_tap_net_ops);
 815 pnet_tap_faied:
 816         unregister_pernet_device(&ipgre_net_ops);
 817         return err;
 818 }
 819
 820 static void __exit ipgre_fini(void)
 821 {
 822         rtnl_link_unregister(&ipgre_tap_ops);
 823         rtnl_link_unregister(&ipgre_link_ops);
 824         gre_cisco_unregister(&ipgre_protocol);
 825         unregister_pernet_device(&ipgre_tap_net_ops);
 826         unregister_pernet_device(&ipgre_net_ops);
 827 }
 828
 829 module_init(ipgre_init);
 830 module_exit(ipgre_fini);
 831 MODULE_LICENSE("GPL");
 832 MODULE_ALIAS_RTNL_LINK("gre");
 833 MODULE_ALIAS_RTNL_LINK("gretap");
 834 MODULE_ALIAS_NETDEV("gre0");
 835 MODULE_ALIAS_NETDEV("gretap0");