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/if_vlan.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 #include <net/dst_metadata.h> 51 52 /* 53 Problems & solutions 54 -------------------- 55 56 1. The most important issue is detecting local dead loops. 57 They would cause complete host lockup in transmit, which 58 would be "resolved" by stack overflow or, if queueing is enabled, 59 with infinite looping in net_bh. 60 61 We cannot track such dead loops during route installation, 62 it is infeasible task. The most general solutions would be 63 to keep skb->encapsulation counter (sort of local ttl), 64 and silently drop packet when it expires. It is a good 65 solution, but it supposes maintaining new variable in ALL 66 skb, even if no tunneling is used. 67 68 Current solution: xmit_recursion breaks dead loops. This is a percpu 69 counter, since when we enter the first ndo_xmit(), cpu migration is 70 forbidden. We force an exit if this counter reaches RECURSION_LIMIT 71 72 2. Networking dead loops would not kill routers, but would really 73 kill network. IP hop limit plays role of "t->recursion" in this case, 74 if we copy it from packet being encapsulated to upper header. 75 It is very good solution, but it introduces two problems: 76 77 - Routing protocols, using packets with ttl=1 (OSPF, RIP2), 78 do not work over tunnels. 79 - traceroute does not work. I planned to relay ICMP from tunnel, 80 so that this problem would be solved and traceroute output 81 would even more informative. This idea appeared to be wrong: 82 only Linux complies to rfc1812 now (yes, guys, Linux is the only 83 true router now :-)), all routers (at least, in neighbourhood of mine) 84 return only 8 bytes of payload. It is the end. 85 86 Hence, if we want that OSPF worked or traceroute said something reasonable, 87 we should search for another solution. 88 89 One of them is to parse packet trying to detect inner encapsulation 90 made by our node. It is difficult or even impossible, especially, 91 taking into account fragmentation. TO be short, ttl is not solution at all. 92 93 Current solution: The solution was UNEXPECTEDLY SIMPLE. 94 We force DF flag on tunnels with preconfigured hop limit, 95 that is ALL. :-) Well, it does not remove the problem completely, 96 but exponential growth of network traffic is changed to linear 97 (branches, that exceed pmtu are pruned) and tunnel mtu 98 rapidly degrades to value <68, where looping stops. 99 Yes, it is not good if there exists a router in the loop, 100 which does not force DF, even when encapsulating packets have DF set. 101 But it is not our problem! Nobody could accuse us, we made 102 all that we could make. Even if it is your gated who injected 103 fatal route to network, even if it were you who configured 104 fatal static route: you are innocent. :-) 105 106 Alexey Kuznetsov. 107 */ 108 109 static bool log_ecn_error = true; 110 module_param(log_ecn_error, bool, 0644); 111 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN"); 112 113 static struct rtnl_link_ops ipgre_link_ops __read_mostly; 114 static int ipgre_tunnel_init(struct net_device *dev); 115 116 static int ipgre_net_id __read_mostly; 117 static int gre_tap_net_id __read_mostly; 118 119 static void ipgre_err(struct sk_buff *skb, u32 info, 120 const struct tnl_ptk_info *tpi) 121 { 122 123 /* All the routers (except for Linux) return only 124 8 bytes of packet payload. It means, that precise relaying of 125 ICMP in the real Internet is absolutely infeasible. 126 127 Moreover, Cisco "wise men" put GRE key to the third word 128 in GRE header. It makes impossible maintaining even soft 129 state for keyed GRE tunnels with enabled checksum. Tell 130 them "thank you". 131 132 Well, I wonder, rfc1812 was written by Cisco employee, 133 what the hell these idiots break standards established 134 by themselves??? 135 */ 136 struct net *net = dev_net(skb->dev); 137 struct ip_tunnel_net *itn; 138 const struct iphdr *iph; 139 const int type = icmp_hdr(skb)->type; 140 const int code = icmp_hdr(skb)->code; 141 unsigned int data_len = 0; 142 struct ip_tunnel *t; 143 144 switch (type) { 145 default: 146 case ICMP_PARAMETERPROB: 147 return; 148 149 case ICMP_DEST_UNREACH: 150 switch (code) { 151 case ICMP_SR_FAILED: 152 case ICMP_PORT_UNREACH: 153 /* Impossible event. */ 154 return; 155 default: 156 /* All others are translated to HOST_UNREACH. 157 rfc2003 contains "deep thoughts" about NET_UNREACH, 158 I believe they are just ether pollution. --ANK 159 */ 160 break; 161 } 162 break; 163 164 case ICMP_TIME_EXCEEDED: 165 if (code != ICMP_EXC_TTL) 166 return; 167 data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */ 168 break; 169 170 case ICMP_REDIRECT: 171 break; 172 } 173 174 if (tpi->proto == htons(ETH_P_TEB)) 175 itn = net_generic(net, gre_tap_net_id); 176 else 177 itn = net_generic(net, ipgre_net_id); 178 179 iph = (const struct iphdr *)(icmp_hdr(skb) + 1); 180 t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags, 181 iph->daddr, iph->saddr, tpi->key); 182 183 if (!t) 184 return; 185 186 #if IS_ENABLED(CONFIG_IPV6) 187 if (tpi->proto == htons(ETH_P_IPV6) && 188 !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len, 189 type, data_len)) 190 return; 191 #endif 192 193 if (t->parms.iph.daddr == 0 || 194 ipv4_is_multicast(t->parms.iph.daddr)) 195 return; 196 197 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED) 198 return; 199 200 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO)) 201 t->err_count++; 202 else 203 t->err_count = 1; 204 t->err_time = jiffies; 205 } 206 207 static void gre_err(struct sk_buff *skb, u32 info) 208 { 209 /* All the routers (except for Linux) return only 210 * 8 bytes of packet payload. It means, that precise relaying of 211 * ICMP in the real Internet is absolutely infeasible. 212 * 213 * Moreover, Cisco "wise men" put GRE key to the third word 214 * in GRE header. It makes impossible maintaining even soft 215 * state for keyed 216 * GRE tunnels with enabled checksum. Tell them "thank you". 217 * 218 * Well, I wonder, rfc1812 was written by Cisco employee, 219 * what the hell these idiots break standards established 220 * by themselves??? 221 */ 222 223 const struct iphdr *iph = (struct iphdr *)skb->data; 224 const int type = icmp_hdr(skb)->type; 225 const int code = icmp_hdr(skb)->code; 226 struct tnl_ptk_info tpi; 227 bool csum_err = false; 228 229 if (gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 230 iph->ihl * 4) < 0) { 231 if (!csum_err) /* ignore csum errors. */ 232 return; 233 } 234 235 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) { 236 ipv4_update_pmtu(skb, dev_net(skb->dev), info, 237 skb->dev->ifindex, 0, IPPROTO_GRE, 0); 238 return; 239 } 240 if (type == ICMP_REDIRECT) { 241 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0, 242 IPPROTO_GRE, 0); 243 return; 244 } 245 246 ipgre_err(skb, info, &tpi); 247 } 248 249 static __be64 key_to_tunnel_id(__be32 key) 250 { 251 #ifdef __BIG_ENDIAN 252 return (__force __be64)((__force u32)key); 253 #else 254 return (__force __be64)((__force u64)key << 32); 255 #endif 256 } 257 258 /* Returns the least-significant 32 bits of a __be64. */ 259 static __be32 tunnel_id_to_key(__be64 x) 260 { 261 #ifdef __BIG_ENDIAN 262 return (__force __be32)x; 263 #else 264 return (__force __be32)((__force u64)x >> 32); 265 #endif 266 } 267 268 static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi, 269 struct ip_tunnel_net *itn, int hdr_len, bool raw_proto) 270 { 271 struct metadata_dst *tun_dst = NULL; 272 const struct iphdr *iph; 273 struct ip_tunnel *tunnel; 274 275 iph = ip_hdr(skb); 276 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags, 277 iph->saddr, iph->daddr, tpi->key); 278 279 if (tunnel) { 280 if (__iptunnel_pull_header(skb, hdr_len, tpi->proto, 281 raw_proto, false) < 0) 282 goto drop; 283 284 if (tunnel->dev->type != ARPHRD_NONE) 285 skb_pop_mac_header(skb); 286 else 287 skb_reset_mac_header(skb); 288 if (tunnel->collect_md) { 289 __be16 flags; 290 __be64 tun_id; 291 292 flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY); 293 tun_id = key_to_tunnel_id(tpi->key); 294 tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0); 295 if (!tun_dst) 296 return PACKET_REJECT; 297 } 298 299 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error); 300 return PACKET_RCVD; 301 } 302 return PACKET_NEXT; 303 304 drop: 305 kfree_skb(skb); 306 return PACKET_RCVD; 307 } 308 309 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi, 310 int hdr_len) 311 { 312 struct net *net = dev_net(skb->dev); 313 struct ip_tunnel_net *itn; 314 int res; 315 316 if (tpi->proto == htons(ETH_P_TEB)) 317 itn = net_generic(net, gre_tap_net_id); 318 else 319 itn = net_generic(net, ipgre_net_id); 320 321 res = __ipgre_rcv(skb, tpi, itn, hdr_len, false); 322 if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) { 323 /* ipgre tunnels in collect metadata mode should receive 324 * also ETH_P_TEB traffic. 325 */ 326 itn = net_generic(net, ipgre_net_id); 327 res = __ipgre_rcv(skb, tpi, itn, hdr_len, true); 328 } 329 return res; 330 } 331 332 static int gre_rcv(struct sk_buff *skb) 333 { 334 struct tnl_ptk_info tpi; 335 bool csum_err = false; 336 int hdr_len; 337 338 #ifdef CONFIG_NET_IPGRE_BROADCAST 339 if (ipv4_is_multicast(ip_hdr(skb)->daddr)) { 340 /* Looped back packet, drop it! */ 341 if (rt_is_output_route(skb_rtable(skb))) 342 goto drop; 343 } 344 #endif 345 346 hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0); 347 if (hdr_len < 0) 348 goto drop; 349 350 if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD) 351 return 0; 352 353 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0); 354 drop: 355 kfree_skb(skb); 356 return 0; 357 } 358 359 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev, 360 const struct iphdr *tnl_params, 361 __be16 proto) 362 { 363 struct ip_tunnel *tunnel = netdev_priv(dev); 364 365 if (tunnel->parms.o_flags & TUNNEL_SEQ) 366 tunnel->o_seqno++; 367 368 /* Push GRE header. */ 369 gre_build_header(skb, tunnel->tun_hlen, 370 tunnel->parms.o_flags, proto, tunnel->parms.o_key, 371 htonl(tunnel->o_seqno)); 372 373 skb_set_inner_protocol(skb, proto); 374 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol); 375 } 376 377 static int gre_handle_offloads(struct sk_buff *skb, bool csum) 378 { 379 return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE); 380 } 381 382 static struct rtable *gre_get_rt(struct sk_buff *skb, 383 struct net_device *dev, 384 struct flowi4 *fl, 385 const struct ip_tunnel_key *key) 386 { 387 struct net *net = dev_net(dev); 388 389 memset(fl, 0, sizeof(*fl)); 390 fl->daddr = key->u.ipv4.dst; 391 fl->saddr = key->u.ipv4.src; 392 fl->flowi4_tos = RT_TOS(key->tos); 393 fl->flowi4_mark = skb->mark; 394 fl->flowi4_proto = IPPROTO_GRE; 395 396 return ip_route_output_key(net, fl); 397 } 398 399 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev, 400 __be16 proto) 401 { 402 struct ip_tunnel_info *tun_info; 403 const struct ip_tunnel_key *key; 404 struct rtable *rt = NULL; 405 struct flowi4 fl; 406 int min_headroom; 407 int tunnel_hlen; 408 __be16 df, flags; 409 bool use_cache; 410 int err; 411 412 tun_info = skb_tunnel_info(skb); 413 if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) || 414 ip_tunnel_info_af(tun_info) != AF_INET)) 415 goto err_free_skb; 416 417 key = &tun_info->key; 418 use_cache = ip_tunnel_dst_cache_usable(skb, tun_info); 419 if (use_cache) 420 rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr); 421 if (!rt) { 422 rt = gre_get_rt(skb, dev, &fl, key); 423 if (IS_ERR(rt)) 424 goto err_free_skb; 425 if (use_cache) 426 dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst, 427 fl.saddr); 428 } 429 430 tunnel_hlen = gre_calc_hlen(key->tun_flags); 431 432 min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len 433 + tunnel_hlen + sizeof(struct iphdr); 434 if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) { 435 int head_delta = SKB_DATA_ALIGN(min_headroom - 436 skb_headroom(skb) + 437 16); 438 err = pskb_expand_head(skb, max_t(int, head_delta, 0), 439 0, GFP_ATOMIC); 440 if (unlikely(err)) 441 goto err_free_rt; 442 } 443 444 /* Push Tunnel header. */ 445 if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM))) 446 goto err_free_rt; 447 448 flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY); 449 gre_build_header(skb, tunnel_hlen, flags, proto, 450 tunnel_id_to_key(tun_info->key.tun_id), 0); 451 452 df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0; 453 454 iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE, 455 key->tos, key->ttl, df, false); 456 return; 457 458 err_free_rt: 459 ip_rt_put(rt); 460 err_free_skb: 461 kfree_skb(skb); 462 dev->stats.tx_dropped++; 463 } 464 465 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) 466 { 467 struct ip_tunnel_info *info = skb_tunnel_info(skb); 468 struct rtable *rt; 469 struct flowi4 fl4; 470 471 if (ip_tunnel_info_af(info) != AF_INET) 472 return -EINVAL; 473 474 rt = gre_get_rt(skb, dev, &fl4, &info->key); 475 if (IS_ERR(rt)) 476 return PTR_ERR(rt); 477 478 ip_rt_put(rt); 479 info->key.u.ipv4.src = fl4.saddr; 480 return 0; 481 } 482 483 static netdev_tx_t ipgre_xmit(struct sk_buff *skb, 484 struct net_device *dev) 485 { 486 struct ip_tunnel *tunnel = netdev_priv(dev); 487 const struct iphdr *tnl_params; 488 489 if (tunnel->collect_md) { 490 gre_fb_xmit(skb, dev, skb->protocol); 491 return NETDEV_TX_OK; 492 } 493 494 if (dev->header_ops) { 495 /* Need space for new headers */ 496 if (skb_cow_head(skb, dev->needed_headroom - 497 (tunnel->hlen + sizeof(struct iphdr)))) 498 goto free_skb; 499 500 tnl_params = (const struct iphdr *)skb->data; 501 502 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing 503 * to gre header. 504 */ 505 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr)); 506 skb_reset_mac_header(skb); 507 } else { 508 if (skb_cow_head(skb, dev->needed_headroom)) 509 goto free_skb; 510 511 tnl_params = &tunnel->parms.iph; 512 } 513 514 if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM))) 515 goto free_skb; 516 517 __gre_xmit(skb, dev, tnl_params, skb->protocol); 518 return NETDEV_TX_OK; 519 520 free_skb: 521 kfree_skb(skb); 522 dev->stats.tx_dropped++; 523 return NETDEV_TX_OK; 524 } 525 526 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb, 527 struct net_device *dev) 528 { 529 struct ip_tunnel *tunnel = netdev_priv(dev); 530 531 if (tunnel->collect_md) { 532 gre_fb_xmit(skb, dev, htons(ETH_P_TEB)); 533 return NETDEV_TX_OK; 534 } 535 536 if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM))) 537 goto free_skb; 538 539 if (skb_cow_head(skb, dev->needed_headroom)) 540 goto free_skb; 541 542 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB)); 543 return NETDEV_TX_OK; 544 545 free_skb: 546 kfree_skb(skb); 547 dev->stats.tx_dropped++; 548 return NETDEV_TX_OK; 549 } 550 551 static int ipgre_tunnel_ioctl(struct net_device *dev, 552 struct ifreq *ifr, int cmd) 553 { 554 int err; 555 struct ip_tunnel_parm p; 556 557 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) 558 return -EFAULT; 559 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) { 560 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE || 561 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) || 562 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))) 563 return -EINVAL; 564 } 565 p.i_flags = gre_flags_to_tnl_flags(p.i_flags); 566 p.o_flags = gre_flags_to_tnl_flags(p.o_flags); 567 568 err = ip_tunnel_ioctl(dev, &p, cmd); 569 if (err) 570 return err; 571 572 p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags); 573 p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags); 574 575 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) 576 return -EFAULT; 577 return 0; 578 } 579 580 /* Nice toy. Unfortunately, useless in real life :-) 581 It allows to construct virtual multiprotocol broadcast "LAN" 582 over the Internet, provided multicast routing is tuned. 583 584 585 I have no idea was this bicycle invented before me, 586 so that I had to set ARPHRD_IPGRE to a random value. 587 I have an impression, that Cisco could make something similar, 588 but this feature is apparently missing in IOS<=11.2(8). 589 590 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks 591 with broadcast 224.66.66.66. If you have access to mbone, play with me :-) 592 593 ping -t 255 224.66.66.66 594 595 If nobody answers, mbone does not work. 596 597 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255 598 ip addr add 10.66.66.<somewhat>/24 dev Universe 599 ifconfig Universe up 600 ifconfig Universe add fe80::<Your_real_addr>/10 601 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96 602 ftp 10.66.66.66 603 ... 604 ftp fec0:6666:6666::193.233.7.65 605 ... 606 */ 607 static int ipgre_header(struct sk_buff *skb, struct net_device *dev, 608 unsigned short type, 609 const void *daddr, const void *saddr, unsigned int len) 610 { 611 struct ip_tunnel *t = netdev_priv(dev); 612 struct iphdr *iph; 613 struct gre_base_hdr *greh; 614 615 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph)); 616 greh = (struct gre_base_hdr *)(iph+1); 617 greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags); 618 greh->protocol = htons(type); 619 620 memcpy(iph, &t->parms.iph, sizeof(struct iphdr)); 621 622 /* Set the source hardware address. */ 623 if (saddr) 624 memcpy(&iph->saddr, saddr, 4); 625 if (daddr) 626 memcpy(&iph->daddr, daddr, 4); 627 if (iph->daddr) 628 return t->hlen + sizeof(*iph); 629 630 return -(t->hlen + sizeof(*iph)); 631 } 632 633 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr) 634 { 635 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb); 636 memcpy(haddr, &iph->saddr, 4); 637 return 4; 638 } 639 640 static const struct header_ops ipgre_header_ops = { 641 .create = ipgre_header, 642 .parse = ipgre_header_parse, 643 }; 644 645 #ifdef CONFIG_NET_IPGRE_BROADCAST 646 static int ipgre_open(struct net_device *dev) 647 { 648 struct ip_tunnel *t = netdev_priv(dev); 649 650 if (ipv4_is_multicast(t->parms.iph.daddr)) { 651 struct flowi4 fl4; 652 struct rtable *rt; 653 654 rt = ip_route_output_gre(t->net, &fl4, 655 t->parms.iph.daddr, 656 t->parms.iph.saddr, 657 t->parms.o_key, 658 RT_TOS(t->parms.iph.tos), 659 t->parms.link); 660 if (IS_ERR(rt)) 661 return -EADDRNOTAVAIL; 662 dev = rt->dst.dev; 663 ip_rt_put(rt); 664 if (!__in_dev_get_rtnl(dev)) 665 return -EADDRNOTAVAIL; 666 t->mlink = dev->ifindex; 667 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr); 668 } 669 return 0; 670 } 671 672 static int ipgre_close(struct net_device *dev) 673 { 674 struct ip_tunnel *t = netdev_priv(dev); 675 676 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) { 677 struct in_device *in_dev; 678 in_dev = inetdev_by_index(t->net, t->mlink); 679 if (in_dev) 680 ip_mc_dec_group(in_dev, t->parms.iph.daddr); 681 } 682 return 0; 683 } 684 #endif 685 686 static const struct net_device_ops ipgre_netdev_ops = { 687 .ndo_init = ipgre_tunnel_init, 688 .ndo_uninit = ip_tunnel_uninit, 689 #ifdef CONFIG_NET_IPGRE_BROADCAST 690 .ndo_open = ipgre_open, 691 .ndo_stop = ipgre_close, 692 #endif 693 .ndo_start_xmit = ipgre_xmit, 694 .ndo_do_ioctl = ipgre_tunnel_ioctl, 695 .ndo_change_mtu = ip_tunnel_change_mtu, 696 .ndo_get_stats64 = ip_tunnel_get_stats64, 697 .ndo_get_iflink = ip_tunnel_get_iflink, 698 }; 699 700 #define GRE_FEATURES (NETIF_F_SG | \ 701 NETIF_F_FRAGLIST | \ 702 NETIF_F_HIGHDMA | \ 703 NETIF_F_HW_CSUM) 704 705 static void ipgre_tunnel_setup(struct net_device *dev) 706 { 707 dev->netdev_ops = &ipgre_netdev_ops; 708 dev->type = ARPHRD_IPGRE; 709 ip_tunnel_setup(dev, ipgre_net_id); 710 } 711 712 static void __gre_tunnel_init(struct net_device *dev) 713 { 714 struct ip_tunnel *tunnel; 715 int t_hlen; 716 717 tunnel = netdev_priv(dev); 718 tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags); 719 tunnel->parms.iph.protocol = IPPROTO_GRE; 720 721 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen; 722 723 t_hlen = tunnel->hlen + sizeof(struct iphdr); 724 725 dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4; 726 dev->mtu = ETH_DATA_LEN - t_hlen - 4; 727 728 dev->features |= GRE_FEATURES; 729 dev->hw_features |= GRE_FEATURES; 730 731 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) { 732 /* TCP offload with GRE SEQ is not supported, nor 733 * can we support 2 levels of outer headers requiring 734 * an update. 735 */ 736 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) || 737 (tunnel->encap.type == TUNNEL_ENCAP_NONE)) { 738 dev->features |= NETIF_F_GSO_SOFTWARE; 739 dev->hw_features |= NETIF_F_GSO_SOFTWARE; 740 } 741 742 /* Can use a lockless transmit, unless we generate 743 * output sequences 744 */ 745 dev->features |= NETIF_F_LLTX; 746 } 747 } 748 749 static int ipgre_tunnel_init(struct net_device *dev) 750 { 751 struct ip_tunnel *tunnel = netdev_priv(dev); 752 struct iphdr *iph = &tunnel->parms.iph; 753 754 __gre_tunnel_init(dev); 755 756 memcpy(dev->dev_addr, &iph->saddr, 4); 757 memcpy(dev->broadcast, &iph->daddr, 4); 758 759 dev->flags = IFF_NOARP; 760 netif_keep_dst(dev); 761 dev->addr_len = 4; 762 763 if (iph->daddr && !tunnel->collect_md) { 764 #ifdef CONFIG_NET_IPGRE_BROADCAST 765 if (ipv4_is_multicast(iph->daddr)) { 766 if (!iph->saddr) 767 return -EINVAL; 768 dev->flags = IFF_BROADCAST; 769 dev->header_ops = &ipgre_header_ops; 770 } 771 #endif 772 } else if (!tunnel->collect_md) { 773 dev->header_ops = &ipgre_header_ops; 774 } 775 776 return ip_tunnel_init(dev); 777 } 778 779 static const struct gre_protocol ipgre_protocol = { 780 .handler = gre_rcv, 781 .err_handler = gre_err, 782 }; 783 784 static int __net_init ipgre_init_net(struct net *net) 785 { 786 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL); 787 } 788 789 static void __net_exit ipgre_exit_net(struct net *net) 790 { 791 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id); 792 ip_tunnel_delete_net(itn, &ipgre_link_ops); 793 } 794 795 static struct pernet_operations ipgre_net_ops = { 796 .init = ipgre_init_net, 797 .exit = ipgre_exit_net, 798 .id = &ipgre_net_id, 799 .size = sizeof(struct ip_tunnel_net), 800 }; 801 802 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[]) 803 { 804 __be16 flags; 805 806 if (!data) 807 return 0; 808 809 flags = 0; 810 if (data[IFLA_GRE_IFLAGS]) 811 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]); 812 if (data[IFLA_GRE_OFLAGS]) 813 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]); 814 if (flags & (GRE_VERSION|GRE_ROUTING)) 815 return -EINVAL; 816 817 if (data[IFLA_GRE_COLLECT_METADATA] && 818 data[IFLA_GRE_ENCAP_TYPE] && 819 nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE) 820 return -EINVAL; 821 822 return 0; 823 } 824 825 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[]) 826 { 827 __be32 daddr; 828 829 if (tb[IFLA_ADDRESS]) { 830 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 831 return -EINVAL; 832 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 833 return -EADDRNOTAVAIL; 834 } 835 836 if (!data) 837 goto out; 838 839 if (data[IFLA_GRE_REMOTE]) { 840 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4); 841 if (!daddr) 842 return -EINVAL; 843 } 844 845 out: 846 return ipgre_tunnel_validate(tb, data); 847 } 848 849 static int ipgre_netlink_parms(struct net_device *dev, 850 struct nlattr *data[], 851 struct nlattr *tb[], 852 struct ip_tunnel_parm *parms) 853 { 854 struct ip_tunnel *t = netdev_priv(dev); 855 856 memset(parms, 0, sizeof(*parms)); 857 858 parms->iph.protocol = IPPROTO_GRE; 859 860 if (!data) 861 return 0; 862 863 if (data[IFLA_GRE_LINK]) 864 parms->link = nla_get_u32(data[IFLA_GRE_LINK]); 865 866 if (data[IFLA_GRE_IFLAGS]) 867 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS])); 868 869 if (data[IFLA_GRE_OFLAGS]) 870 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS])); 871 872 if (data[IFLA_GRE_IKEY]) 873 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]); 874 875 if (data[IFLA_GRE_OKEY]) 876 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]); 877 878 if (data[IFLA_GRE_LOCAL]) 879 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]); 880 881 if (data[IFLA_GRE_REMOTE]) 882 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]); 883 884 if (data[IFLA_GRE_TTL]) 885 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]); 886 887 if (data[IFLA_GRE_TOS]) 888 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]); 889 890 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) { 891 if (t->ignore_df) 892 return -EINVAL; 893 parms->iph.frag_off = htons(IP_DF); 894 } 895 896 if (data[IFLA_GRE_COLLECT_METADATA]) { 897 t->collect_md = true; 898 if (dev->type == ARPHRD_IPGRE) 899 dev->type = ARPHRD_NONE; 900 } 901 902 if (data[IFLA_GRE_IGNORE_DF]) { 903 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF]) 904 && (parms->iph.frag_off & htons(IP_DF))) 905 return -EINVAL; 906 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]); 907 } 908 909 return 0; 910 } 911 912 /* This function returns true when ENCAP attributes are present in the nl msg */ 913 static bool ipgre_netlink_encap_parms(struct nlattr *data[], 914 struct ip_tunnel_encap *ipencap) 915 { 916 bool ret = false; 917 918 memset(ipencap, 0, sizeof(*ipencap)); 919 920 if (!data) 921 return ret; 922 923 if (data[IFLA_GRE_ENCAP_TYPE]) { 924 ret = true; 925 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]); 926 } 927 928 if (data[IFLA_GRE_ENCAP_FLAGS]) { 929 ret = true; 930 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]); 931 } 932 933 if (data[IFLA_GRE_ENCAP_SPORT]) { 934 ret = true; 935 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]); 936 } 937 938 if (data[IFLA_GRE_ENCAP_DPORT]) { 939 ret = true; 940 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]); 941 } 942 943 return ret; 944 } 945 946 static int gre_tap_init(struct net_device *dev) 947 { 948 __gre_tunnel_init(dev); 949 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 950 951 return ip_tunnel_init(dev); 952 } 953 954 static const struct net_device_ops gre_tap_netdev_ops = { 955 .ndo_init = gre_tap_init, 956 .ndo_uninit = ip_tunnel_uninit, 957 .ndo_start_xmit = gre_tap_xmit, 958 .ndo_set_mac_address = eth_mac_addr, 959 .ndo_validate_addr = eth_validate_addr, 960 .ndo_change_mtu = ip_tunnel_change_mtu, 961 .ndo_get_stats64 = ip_tunnel_get_stats64, 962 .ndo_get_iflink = ip_tunnel_get_iflink, 963 .ndo_fill_metadata_dst = gre_fill_metadata_dst, 964 }; 965 966 static void ipgre_tap_setup(struct net_device *dev) 967 { 968 ether_setup(dev); 969 dev->netdev_ops = &gre_tap_netdev_ops; 970 dev->priv_flags &= ~IFF_TX_SKB_SHARING; 971 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 972 ip_tunnel_setup(dev, gre_tap_net_id); 973 } 974 975 static int ipgre_newlink(struct net *src_net, struct net_device *dev, 976 struct nlattr *tb[], struct nlattr *data[]) 977 { 978 struct ip_tunnel_parm p; 979 struct ip_tunnel_encap ipencap; 980 int err; 981 982 if (ipgre_netlink_encap_parms(data, &ipencap)) { 983 struct ip_tunnel *t = netdev_priv(dev); 984 err = ip_tunnel_encap_setup(t, &ipencap); 985 986 if (err < 0) 987 return err; 988 } 989 990 err = ipgre_netlink_parms(dev, data, tb, &p); 991 if (err < 0) 992 return err; 993 return ip_tunnel_newlink(dev, tb, &p); 994 } 995 996 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[], 997 struct nlattr *data[]) 998 { 999 struct ip_tunnel_parm p; 1000 struct ip_tunnel_encap ipencap; 1001 int err; 1002 1003 if (ipgre_netlink_encap_parms(data, &ipencap)) { 1004 struct ip_tunnel *t = netdev_priv(dev); 1005 err = ip_tunnel_encap_setup(t, &ipencap); 1006 1007 if (err < 0) 1008 return err; 1009 } 1010 1011 err = ipgre_netlink_parms(dev, data, tb, &p); 1012 if (err < 0) 1013 return err; 1014 return ip_tunnel_changelink(dev, tb, &p); 1015 } 1016 1017 static size_t ipgre_get_size(const struct net_device *dev) 1018 { 1019 return 1020 /* IFLA_GRE_LINK */ 1021 nla_total_size(4) + 1022 /* IFLA_GRE_IFLAGS */ 1023 nla_total_size(2) + 1024 /* IFLA_GRE_OFLAGS */ 1025 nla_total_size(2) + 1026 /* IFLA_GRE_IKEY */ 1027 nla_total_size(4) + 1028 /* IFLA_GRE_OKEY */ 1029 nla_total_size(4) + 1030 /* IFLA_GRE_LOCAL */ 1031 nla_total_size(4) + 1032 /* IFLA_GRE_REMOTE */ 1033 nla_total_size(4) + 1034 /* IFLA_GRE_TTL */ 1035 nla_total_size(1) + 1036 /* IFLA_GRE_TOS */ 1037 nla_total_size(1) + 1038 /* IFLA_GRE_PMTUDISC */ 1039 nla_total_size(1) + 1040 /* IFLA_GRE_ENCAP_TYPE */ 1041 nla_total_size(2) + 1042 /* IFLA_GRE_ENCAP_FLAGS */ 1043 nla_total_size(2) + 1044 /* IFLA_GRE_ENCAP_SPORT */ 1045 nla_total_size(2) + 1046 /* IFLA_GRE_ENCAP_DPORT */ 1047 nla_total_size(2) + 1048 /* IFLA_GRE_COLLECT_METADATA */ 1049 nla_total_size(0) + 1050 /* IFLA_GRE_IGNORE_DF */ 1051 nla_total_size(1) + 1052 0; 1053 } 1054 1055 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev) 1056 { 1057 struct ip_tunnel *t = netdev_priv(dev); 1058 struct ip_tunnel_parm *p = &t->parms; 1059 1060 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) || 1061 nla_put_be16(skb, IFLA_GRE_IFLAGS, 1062 gre_tnl_flags_to_gre_flags(p->i_flags)) || 1063 nla_put_be16(skb, IFLA_GRE_OFLAGS, 1064 gre_tnl_flags_to_gre_flags(p->o_flags)) || 1065 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) || 1066 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) || 1067 nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) || 1068 nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) || 1069 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) || 1070 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) || 1071 nla_put_u8(skb, IFLA_GRE_PMTUDISC, 1072 !!(p->iph.frag_off & htons(IP_DF)))) 1073 goto nla_put_failure; 1074 1075 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE, 1076 t->encap.type) || 1077 nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT, 1078 t->encap.sport) || 1079 nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT, 1080 t->encap.dport) || 1081 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS, 1082 t->encap.flags)) 1083 goto nla_put_failure; 1084 1085 if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df)) 1086 goto nla_put_failure; 1087 1088 if (t->collect_md) { 1089 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA)) 1090 goto nla_put_failure; 1091 } 1092 1093 return 0; 1094 1095 nla_put_failure: 1096 return -EMSGSIZE; 1097 } 1098 1099 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = { 1100 [IFLA_GRE_LINK] = { .type = NLA_U32 }, 1101 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 }, 1102 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 }, 1103 [IFLA_GRE_IKEY] = { .type = NLA_U32 }, 1104 [IFLA_GRE_OKEY] = { .type = NLA_U32 }, 1105 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) }, 1106 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) }, 1107 [IFLA_GRE_TTL] = { .type = NLA_U8 }, 1108 [IFLA_GRE_TOS] = { .type = NLA_U8 }, 1109 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 }, 1110 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 }, 1111 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 }, 1112 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 }, 1113 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 }, 1114 [IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG }, 1115 [IFLA_GRE_IGNORE_DF] = { .type = NLA_U8 }, 1116 }; 1117 1118 static struct rtnl_link_ops ipgre_link_ops __read_mostly = { 1119 .kind = "gre", 1120 .maxtype = IFLA_GRE_MAX, 1121 .policy = ipgre_policy, 1122 .priv_size = sizeof(struct ip_tunnel), 1123 .setup = ipgre_tunnel_setup, 1124 .validate = ipgre_tunnel_validate, 1125 .newlink = ipgre_newlink, 1126 .changelink = ipgre_changelink, 1127 .dellink = ip_tunnel_dellink, 1128 .get_size = ipgre_get_size, 1129 .fill_info = ipgre_fill_info, 1130 .get_link_net = ip_tunnel_get_link_net, 1131 }; 1132 1133 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = { 1134 .kind = "gretap", 1135 .maxtype = IFLA_GRE_MAX, 1136 .policy = ipgre_policy, 1137 .priv_size = sizeof(struct ip_tunnel), 1138 .setup = ipgre_tap_setup, 1139 .validate = ipgre_tap_validate, 1140 .newlink = ipgre_newlink, 1141 .changelink = ipgre_changelink, 1142 .dellink = ip_tunnel_dellink, 1143 .get_size = ipgre_get_size, 1144 .fill_info = ipgre_fill_info, 1145 .get_link_net = ip_tunnel_get_link_net, 1146 }; 1147 1148 struct net_device *gretap_fb_dev_create(struct net *net, const char *name, 1149 u8 name_assign_type) 1150 { 1151 struct nlattr *tb[IFLA_MAX + 1]; 1152 struct net_device *dev; 1153 LIST_HEAD(list_kill); 1154 struct ip_tunnel *t; 1155 int err; 1156 1157 memset(&tb, 0, sizeof(tb)); 1158 1159 dev = rtnl_create_link(net, name, name_assign_type, 1160 &ipgre_tap_ops, tb); 1161 if (IS_ERR(dev)) 1162 return dev; 1163 1164 /* Configure flow based GRE device. */ 1165 t = netdev_priv(dev); 1166 t->collect_md = true; 1167 1168 err = ipgre_newlink(net, dev, tb, NULL); 1169 if (err < 0) { 1170 free_netdev(dev); 1171 return ERR_PTR(err); 1172 } 1173 1174 /* openvswitch users expect packet sizes to be unrestricted, 1175 * so set the largest MTU we can. 1176 */ 1177 err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false); 1178 if (err) 1179 goto out; 1180 1181 err = rtnl_configure_link(dev, NULL); 1182 if (err < 0) 1183 goto out; 1184 1185 return dev; 1186 out: 1187 ip_tunnel_dellink(dev, &list_kill); 1188 unregister_netdevice_many(&list_kill); 1189 return ERR_PTR(err); 1190 } 1191 EXPORT_SYMBOL_GPL(gretap_fb_dev_create); 1192 1193 static int __net_init ipgre_tap_init_net(struct net *net) 1194 { 1195 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0"); 1196 } 1197 1198 static void __net_exit ipgre_tap_exit_net(struct net *net) 1199 { 1200 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id); 1201 ip_tunnel_delete_net(itn, &ipgre_tap_ops); 1202 } 1203 1204 static struct pernet_operations ipgre_tap_net_ops = { 1205 .init = ipgre_tap_init_net, 1206 .exit = ipgre_tap_exit_net, 1207 .id = &gre_tap_net_id, 1208 .size = sizeof(struct ip_tunnel_net), 1209 }; 1210 1211 static int __init ipgre_init(void) 1212 { 1213 int err; 1214 1215 pr_info("GRE over IPv4 tunneling driver\n"); 1216 1217 err = register_pernet_device(&ipgre_net_ops); 1218 if (err < 0) 1219 return err; 1220 1221 err = register_pernet_device(&ipgre_tap_net_ops); 1222 if (err < 0) 1223 goto pnet_tap_faied; 1224 1225 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO); 1226 if (err < 0) { 1227 pr_info("%s: can't add protocol\n", __func__); 1228 goto add_proto_failed; 1229 } 1230 1231 err = rtnl_link_register(&ipgre_link_ops); 1232 if (err < 0) 1233 goto rtnl_link_failed; 1234 1235 err = rtnl_link_register(&ipgre_tap_ops); 1236 if (err < 0) 1237 goto tap_ops_failed; 1238 1239 return 0; 1240 1241 tap_ops_failed: 1242 rtnl_link_unregister(&ipgre_link_ops); 1243 rtnl_link_failed: 1244 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO); 1245 add_proto_failed: 1246 unregister_pernet_device(&ipgre_tap_net_ops); 1247 pnet_tap_faied: 1248 unregister_pernet_device(&ipgre_net_ops); 1249 return err; 1250 } 1251 1252 static void __exit ipgre_fini(void) 1253 { 1254 rtnl_link_unregister(&ipgre_tap_ops); 1255 rtnl_link_unregister(&ipgre_link_ops); 1256 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO); 1257 unregister_pernet_device(&ipgre_tap_net_ops); 1258 unregister_pernet_device(&ipgre_net_ops); 1259 } 1260 1261 module_init(ipgre_init); 1262 module_exit(ipgre_fini); 1263 MODULE_LICENSE("GPL"); 1264 MODULE_ALIAS_RTNL_LINK("gre"); 1265 MODULE_ALIAS_RTNL_LINK("gretap"); 1266 MODULE_ALIAS_NETDEV("gre0"); 1267 MODULE_ALIAS_NETDEV("gretap0"); 1268