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