1 /* 2 * Linux NET3: IP/IP protocol decoder. 3 * 4 * Authors: 5 * Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95 6 * 7 * Fixes: 8 * Alan Cox : Merged and made usable non modular (its so tiny its silly as 9 * a module taking up 2 pages). 10 * Alan Cox : Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph) 11 * to keep ip_forward happy. 12 * Alan Cox : More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8). 13 * Kai Schulte : Fixed #defines for IP_FIREWALL->FIREWALL 14 * David Woodhouse : Perform some basic ICMP handling. 15 * IPIP Routing without decapsulation. 16 * Carlos Picoto : GRE over IP support 17 * Alexey Kuznetsov: Reworked. Really, now it is truncated version of ipv4/ip_gre.c. 18 * I do not want to merge them together. 19 * 20 * This program is free software; you can redistribute it and/or 21 * modify it under the terms of the GNU General Public License 22 * as published by the Free Software Foundation; either version 23 * 2 of the License, or (at your option) any later version. 24 * 25 */ 26 27 /* tunnel.c: an IP tunnel driver 28 29 The purpose of this driver is to provide an IP tunnel through 30 which you can tunnel network traffic transparently across subnets. 31 32 This was written by looking at Nick Holloway's dummy driver 33 Thanks for the great code! 34 35 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95 36 37 Minor tweaks: 38 Cleaned up the code a little and added some pre-1.3.0 tweaks. 39 dev->hard_header/hard_header_len changed to use no headers. 40 Comments/bracketing tweaked. 41 Made the tunnels use dev->name not tunnel: when error reporting. 42 Added tx_dropped stat 43 44 -Alan Cox (alan@lxorguk.ukuu.org.uk) 21 March 95 45 46 Reworked: 47 Changed to tunnel to destination gateway in addition to the 48 tunnel's pointopoint address 49 Almost completely rewritten 50 Note: There is currently no firewall or ICMP handling done. 51 52 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96 53 54 */ 55 56 /* Things I wish I had known when writing the tunnel driver: 57 58 When the tunnel_xmit() function is called, the skb contains the 59 packet to be sent (plus a great deal of extra info), and dev 60 contains the tunnel device that _we_ are. 61 62 When we are passed a packet, we are expected to fill in the 63 source address with our source IP address. 64 65 What is the proper way to allocate, copy and free a buffer? 66 After you allocate it, it is a "0 length" chunk of memory 67 starting at zero. If you want to add headers to the buffer 68 later, you'll have to call "skb_reserve(skb, amount)" with 69 the amount of memory you want reserved. Then, you call 70 "skb_put(skb, amount)" with the amount of space you want in 71 the buffer. skb_put() returns a pointer to the top (#0) of 72 that buffer. skb->len is set to the amount of space you have 73 "allocated" with skb_put(). You can then write up to skb->len 74 bytes to that buffer. If you need more, you can call skb_put() 75 again with the additional amount of space you need. You can 76 find out how much more space you can allocate by calling 77 "skb_tailroom(skb)". 78 Now, to add header space, call "skb_push(skb, header_len)". 79 This creates space at the beginning of the buffer and returns 80 a pointer to this new space. If later you need to strip a 81 header from a buffer, call "skb_pull(skb, header_len)". 82 skb_headroom() will return how much space is left at the top 83 of the buffer (before the main data). Remember, this headroom 84 space must be reserved before the skb_put() function is called. 85 */ 86 87 /* 88 This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c 89 90 For comments look at net/ipv4/ip_gre.c --ANK 91 */ 92 93 94 #include <linux/capability.h> 95 #include <linux/module.h> 96 #include <linux/types.h> 97 #include <linux/kernel.h> 98 #include <linux/slab.h> 99 #include <linux/uaccess.h> 100 #include <linux/skbuff.h> 101 #include <linux/netdevice.h> 102 #include <linux/in.h> 103 #include <linux/tcp.h> 104 #include <linux/udp.h> 105 #include <linux/if_arp.h> 106 #include <linux/init.h> 107 #include <linux/netfilter_ipv4.h> 108 #include <linux/if_ether.h> 109 110 #include <net/sock.h> 111 #include <net/ip.h> 112 #include <net/icmp.h> 113 #include <net/ip_tunnels.h> 114 #include <net/inet_ecn.h> 115 #include <net/xfrm.h> 116 #include <net/net_namespace.h> 117 #include <net/netns/generic.h> 118 #include <net/dst_metadata.h> 119 120 static bool log_ecn_error = true; 121 module_param(log_ecn_error, bool, 0644); 122 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN"); 123 124 static unsigned int ipip_net_id __read_mostly; 125 126 static int ipip_tunnel_init(struct net_device *dev); 127 static struct rtnl_link_ops ipip_link_ops __read_mostly; 128 129 static int ipip_err(struct sk_buff *skb, u32 info) 130 { 131 /* All the routers (except for Linux) return only 132 * 8 bytes of packet payload. It means, that precise relaying of 133 * ICMP in the real Internet is absolutely infeasible. 134 */ 135 struct net *net = dev_net(skb->dev); 136 struct ip_tunnel_net *itn = net_generic(net, ipip_net_id); 137 const struct iphdr *iph = (const struct iphdr *)skb->data; 138 const int type = icmp_hdr(skb)->type; 139 const int code = icmp_hdr(skb)->code; 140 struct ip_tunnel *t; 141 int err = 0; 142 143 t = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY, 144 iph->daddr, iph->saddr, 0); 145 if (!t) { 146 err = -ENOENT; 147 goto out; 148 } 149 150 switch (type) { 151 case ICMP_DEST_UNREACH: 152 switch (code) { 153 case ICMP_SR_FAILED: 154 /* Impossible event. */ 155 goto out; 156 default: 157 /* All others are translated to HOST_UNREACH. 158 * rfc2003 contains "deep thoughts" about NET_UNREACH, 159 * I believe they are just ether pollution. --ANK 160 */ 161 break; 162 } 163 break; 164 165 case ICMP_TIME_EXCEEDED: 166 if (code != ICMP_EXC_TTL) 167 goto out; 168 break; 169 170 case ICMP_REDIRECT: 171 break; 172 173 default: 174 goto out; 175 } 176 177 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) { 178 ipv4_update_pmtu(skb, net, info, t->parms.link, iph->protocol); 179 goto out; 180 } 181 182 if (type == ICMP_REDIRECT) { 183 ipv4_redirect(skb, net, t->parms.link, iph->protocol); 184 goto out; 185 } 186 187 if (t->parms.iph.daddr == 0) { 188 err = -ENOENT; 189 goto out; 190 } 191 192 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED) 193 goto out; 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 201 out: 202 return err; 203 } 204 205 static const struct tnl_ptk_info ipip_tpi = { 206 /* no tunnel info required for ipip. */ 207 .proto = htons(ETH_P_IP), 208 }; 209 210 #if IS_ENABLED(CONFIG_MPLS) 211 static const struct tnl_ptk_info mplsip_tpi = { 212 /* no tunnel info required for mplsip. */ 213 .proto = htons(ETH_P_MPLS_UC), 214 }; 215 #endif 216 217 static int ipip_tunnel_rcv(struct sk_buff *skb, u8 ipproto) 218 { 219 struct net *net = dev_net(skb->dev); 220 struct ip_tunnel_net *itn = net_generic(net, ipip_net_id); 221 struct metadata_dst *tun_dst = NULL; 222 struct ip_tunnel *tunnel; 223 const struct iphdr *iph; 224 225 iph = ip_hdr(skb); 226 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY, 227 iph->saddr, iph->daddr, 0); 228 if (tunnel) { 229 const struct tnl_ptk_info *tpi; 230 231 if (tunnel->parms.iph.protocol != ipproto && 232 tunnel->parms.iph.protocol != 0) 233 goto drop; 234 235 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) 236 goto drop; 237 #if IS_ENABLED(CONFIG_MPLS) 238 if (ipproto == IPPROTO_MPLS) 239 tpi = &mplsip_tpi; 240 else 241 #endif 242 tpi = &ipip_tpi; 243 if (iptunnel_pull_header(skb, 0, tpi->proto, false)) 244 goto drop; 245 if (tunnel->collect_md) { 246 tun_dst = ip_tun_rx_dst(skb, 0, 0, 0); 247 if (!tun_dst) 248 return 0; 249 } 250 return ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error); 251 } 252 253 return -1; 254 255 drop: 256 kfree_skb(skb); 257 return 0; 258 } 259 260 static int ipip_rcv(struct sk_buff *skb) 261 { 262 return ipip_tunnel_rcv(skb, IPPROTO_IPIP); 263 } 264 265 #if IS_ENABLED(CONFIG_MPLS) 266 static int mplsip_rcv(struct sk_buff *skb) 267 { 268 return ipip_tunnel_rcv(skb, IPPROTO_MPLS); 269 } 270 #endif 271 272 /* 273 * This function assumes it is being called from dev_queue_xmit() 274 * and that skb is filled properly by that function. 275 */ 276 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, 277 struct net_device *dev) 278 { 279 struct ip_tunnel *tunnel = netdev_priv(dev); 280 const struct iphdr *tiph = &tunnel->parms.iph; 281 u8 ipproto; 282 283 switch (skb->protocol) { 284 case htons(ETH_P_IP): 285 ipproto = IPPROTO_IPIP; 286 break; 287 #if IS_ENABLED(CONFIG_MPLS) 288 case htons(ETH_P_MPLS_UC): 289 ipproto = IPPROTO_MPLS; 290 break; 291 #endif 292 default: 293 goto tx_error; 294 } 295 296 if (tiph->protocol != ipproto && tiph->protocol != 0) 297 goto tx_error; 298 299 if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4)) 300 goto tx_error; 301 302 skb_set_inner_ipproto(skb, ipproto); 303 304 if (tunnel->collect_md) 305 ip_md_tunnel_xmit(skb, dev, ipproto); 306 else 307 ip_tunnel_xmit(skb, dev, tiph, ipproto); 308 return NETDEV_TX_OK; 309 310 tx_error: 311 kfree_skb(skb); 312 313 dev->stats.tx_errors++; 314 return NETDEV_TX_OK; 315 } 316 317 static bool ipip_tunnel_ioctl_verify_protocol(u8 ipproto) 318 { 319 switch (ipproto) { 320 case 0: 321 case IPPROTO_IPIP: 322 #if IS_ENABLED(CONFIG_MPLS) 323 case IPPROTO_MPLS: 324 #endif 325 return true; 326 } 327 328 return false; 329 } 330 331 static int 332 ipip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 333 { 334 int err = 0; 335 struct ip_tunnel_parm p; 336 337 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) 338 return -EFAULT; 339 340 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) { 341 if (p.iph.version != 4 || 342 !ipip_tunnel_ioctl_verify_protocol(p.iph.protocol) || 343 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF))) 344 return -EINVAL; 345 } 346 347 p.i_key = p.o_key = 0; 348 p.i_flags = p.o_flags = 0; 349 err = ip_tunnel_ioctl(dev, &p, cmd); 350 if (err) 351 return err; 352 353 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) 354 return -EFAULT; 355 356 return 0; 357 } 358 359 static const struct net_device_ops ipip_netdev_ops = { 360 .ndo_init = ipip_tunnel_init, 361 .ndo_uninit = ip_tunnel_uninit, 362 .ndo_start_xmit = ipip_tunnel_xmit, 363 .ndo_do_ioctl = ipip_tunnel_ioctl, 364 .ndo_change_mtu = ip_tunnel_change_mtu, 365 .ndo_get_stats64 = ip_tunnel_get_stats64, 366 .ndo_get_iflink = ip_tunnel_get_iflink, 367 }; 368 369 #define IPIP_FEATURES (NETIF_F_SG | \ 370 NETIF_F_FRAGLIST | \ 371 NETIF_F_HIGHDMA | \ 372 NETIF_F_GSO_SOFTWARE | \ 373 NETIF_F_HW_CSUM) 374 375 static void ipip_tunnel_setup(struct net_device *dev) 376 { 377 dev->netdev_ops = &ipip_netdev_ops; 378 379 dev->type = ARPHRD_TUNNEL; 380 dev->flags = IFF_NOARP; 381 dev->addr_len = 4; 382 dev->features |= NETIF_F_LLTX; 383 netif_keep_dst(dev); 384 385 dev->features |= IPIP_FEATURES; 386 dev->hw_features |= IPIP_FEATURES; 387 ip_tunnel_setup(dev, ipip_net_id); 388 } 389 390 static int ipip_tunnel_init(struct net_device *dev) 391 { 392 struct ip_tunnel *tunnel = netdev_priv(dev); 393 394 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4); 395 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4); 396 397 tunnel->tun_hlen = 0; 398 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen; 399 return ip_tunnel_init(dev); 400 } 401 402 static int ipip_tunnel_validate(struct nlattr *tb[], struct nlattr *data[], 403 struct netlink_ext_ack *extack) 404 { 405 u8 proto; 406 407 if (!data || !data[IFLA_IPTUN_PROTO]) 408 return 0; 409 410 proto = nla_get_u8(data[IFLA_IPTUN_PROTO]); 411 if (proto != IPPROTO_IPIP && proto != IPPROTO_MPLS && proto != 0) 412 return -EINVAL; 413 414 return 0; 415 } 416 417 static void ipip_netlink_parms(struct nlattr *data[], 418 struct ip_tunnel_parm *parms, bool *collect_md, 419 __u32 *fwmark) 420 { 421 memset(parms, 0, sizeof(*parms)); 422 423 parms->iph.version = 4; 424 parms->iph.protocol = IPPROTO_IPIP; 425 parms->iph.ihl = 5; 426 *collect_md = false; 427 428 if (!data) 429 return; 430 431 if (data[IFLA_IPTUN_LINK]) 432 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]); 433 434 if (data[IFLA_IPTUN_LOCAL]) 435 parms->iph.saddr = nla_get_in_addr(data[IFLA_IPTUN_LOCAL]); 436 437 if (data[IFLA_IPTUN_REMOTE]) 438 parms->iph.daddr = nla_get_in_addr(data[IFLA_IPTUN_REMOTE]); 439 440 if (data[IFLA_IPTUN_TTL]) { 441 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]); 442 if (parms->iph.ttl) 443 parms->iph.frag_off = htons(IP_DF); 444 } 445 446 if (data[IFLA_IPTUN_TOS]) 447 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]); 448 449 if (data[IFLA_IPTUN_PROTO]) 450 parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]); 451 452 if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC])) 453 parms->iph.frag_off = htons(IP_DF); 454 455 if (data[IFLA_IPTUN_COLLECT_METADATA]) 456 *collect_md = true; 457 458 if (data[IFLA_IPTUN_FWMARK]) 459 *fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]); 460 } 461 462 /* This function returns true when ENCAP attributes are present in the nl msg */ 463 static bool ipip_netlink_encap_parms(struct nlattr *data[], 464 struct ip_tunnel_encap *ipencap) 465 { 466 bool ret = false; 467 468 memset(ipencap, 0, sizeof(*ipencap)); 469 470 if (!data) 471 return ret; 472 473 if (data[IFLA_IPTUN_ENCAP_TYPE]) { 474 ret = true; 475 ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]); 476 } 477 478 if (data[IFLA_IPTUN_ENCAP_FLAGS]) { 479 ret = true; 480 ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]); 481 } 482 483 if (data[IFLA_IPTUN_ENCAP_SPORT]) { 484 ret = true; 485 ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]); 486 } 487 488 if (data[IFLA_IPTUN_ENCAP_DPORT]) { 489 ret = true; 490 ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]); 491 } 492 493 return ret; 494 } 495 496 static int ipip_newlink(struct net *src_net, struct net_device *dev, 497 struct nlattr *tb[], struct nlattr *data[], 498 struct netlink_ext_ack *extack) 499 { 500 struct ip_tunnel *t = netdev_priv(dev); 501 struct ip_tunnel_parm p; 502 struct ip_tunnel_encap ipencap; 503 __u32 fwmark = 0; 504 505 if (ipip_netlink_encap_parms(data, &ipencap)) { 506 int err = ip_tunnel_encap_setup(t, &ipencap); 507 508 if (err < 0) 509 return err; 510 } 511 512 ipip_netlink_parms(data, &p, &t->collect_md, &fwmark); 513 return ip_tunnel_newlink(dev, tb, &p, fwmark); 514 } 515 516 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[], 517 struct nlattr *data[], 518 struct netlink_ext_ack *extack) 519 { 520 struct ip_tunnel *t = netdev_priv(dev); 521 struct ip_tunnel_parm p; 522 struct ip_tunnel_encap ipencap; 523 bool collect_md; 524 __u32 fwmark = t->fwmark; 525 526 if (ipip_netlink_encap_parms(data, &ipencap)) { 527 int err = ip_tunnel_encap_setup(t, &ipencap); 528 529 if (err < 0) 530 return err; 531 } 532 533 ipip_netlink_parms(data, &p, &collect_md, &fwmark); 534 if (collect_md) 535 return -EINVAL; 536 537 if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) || 538 (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr)) 539 return -EINVAL; 540 541 return ip_tunnel_changelink(dev, tb, &p, fwmark); 542 } 543 544 static size_t ipip_get_size(const struct net_device *dev) 545 { 546 return 547 /* IFLA_IPTUN_LINK */ 548 nla_total_size(4) + 549 /* IFLA_IPTUN_LOCAL */ 550 nla_total_size(4) + 551 /* IFLA_IPTUN_REMOTE */ 552 nla_total_size(4) + 553 /* IFLA_IPTUN_TTL */ 554 nla_total_size(1) + 555 /* IFLA_IPTUN_TOS */ 556 nla_total_size(1) + 557 /* IFLA_IPTUN_PROTO */ 558 nla_total_size(1) + 559 /* IFLA_IPTUN_PMTUDISC */ 560 nla_total_size(1) + 561 /* IFLA_IPTUN_ENCAP_TYPE */ 562 nla_total_size(2) + 563 /* IFLA_IPTUN_ENCAP_FLAGS */ 564 nla_total_size(2) + 565 /* IFLA_IPTUN_ENCAP_SPORT */ 566 nla_total_size(2) + 567 /* IFLA_IPTUN_ENCAP_DPORT */ 568 nla_total_size(2) + 569 /* IFLA_IPTUN_COLLECT_METADATA */ 570 nla_total_size(0) + 571 /* IFLA_IPTUN_FWMARK */ 572 nla_total_size(4) + 573 0; 574 } 575 576 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev) 577 { 578 struct ip_tunnel *tunnel = netdev_priv(dev); 579 struct ip_tunnel_parm *parm = &tunnel->parms; 580 581 if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) || 582 nla_put_in_addr(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) || 583 nla_put_in_addr(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) || 584 nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) || 585 nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) || 586 nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) || 587 nla_put_u8(skb, IFLA_IPTUN_PMTUDISC, 588 !!(parm->iph.frag_off & htons(IP_DF))) || 589 nla_put_u32(skb, IFLA_IPTUN_FWMARK, tunnel->fwmark)) 590 goto nla_put_failure; 591 592 if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE, 593 tunnel->encap.type) || 594 nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT, 595 tunnel->encap.sport) || 596 nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT, 597 tunnel->encap.dport) || 598 nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS, 599 tunnel->encap.flags)) 600 goto nla_put_failure; 601 602 if (tunnel->collect_md) 603 if (nla_put_flag(skb, IFLA_IPTUN_COLLECT_METADATA)) 604 goto nla_put_failure; 605 return 0; 606 607 nla_put_failure: 608 return -EMSGSIZE; 609 } 610 611 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = { 612 [IFLA_IPTUN_LINK] = { .type = NLA_U32 }, 613 [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 }, 614 [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 }, 615 [IFLA_IPTUN_TTL] = { .type = NLA_U8 }, 616 [IFLA_IPTUN_TOS] = { .type = NLA_U8 }, 617 [IFLA_IPTUN_PROTO] = { .type = NLA_U8 }, 618 [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 }, 619 [IFLA_IPTUN_ENCAP_TYPE] = { .type = NLA_U16 }, 620 [IFLA_IPTUN_ENCAP_FLAGS] = { .type = NLA_U16 }, 621 [IFLA_IPTUN_ENCAP_SPORT] = { .type = NLA_U16 }, 622 [IFLA_IPTUN_ENCAP_DPORT] = { .type = NLA_U16 }, 623 [IFLA_IPTUN_COLLECT_METADATA] = { .type = NLA_FLAG }, 624 [IFLA_IPTUN_FWMARK] = { .type = NLA_U32 }, 625 }; 626 627 static struct rtnl_link_ops ipip_link_ops __read_mostly = { 628 .kind = "ipip", 629 .maxtype = IFLA_IPTUN_MAX, 630 .policy = ipip_policy, 631 .priv_size = sizeof(struct ip_tunnel), 632 .setup = ipip_tunnel_setup, 633 .validate = ipip_tunnel_validate, 634 .newlink = ipip_newlink, 635 .changelink = ipip_changelink, 636 .dellink = ip_tunnel_dellink, 637 .get_size = ipip_get_size, 638 .fill_info = ipip_fill_info, 639 .get_link_net = ip_tunnel_get_link_net, 640 }; 641 642 static struct xfrm_tunnel ipip_handler __read_mostly = { 643 .handler = ipip_rcv, 644 .err_handler = ipip_err, 645 .priority = 1, 646 }; 647 648 #if IS_ENABLED(CONFIG_MPLS) 649 static struct xfrm_tunnel mplsip_handler __read_mostly = { 650 .handler = mplsip_rcv, 651 .err_handler = ipip_err, 652 .priority = 1, 653 }; 654 #endif 655 656 static int __net_init ipip_init_net(struct net *net) 657 { 658 return ip_tunnel_init_net(net, ipip_net_id, &ipip_link_ops, "tunl0"); 659 } 660 661 static void __net_exit ipip_exit_batch_net(struct list_head *list_net) 662 { 663 ip_tunnel_delete_nets(list_net, ipip_net_id, &ipip_link_ops); 664 } 665 666 static struct pernet_operations ipip_net_ops = { 667 .init = ipip_init_net, 668 .exit_batch = ipip_exit_batch_net, 669 .id = &ipip_net_id, 670 .size = sizeof(struct ip_tunnel_net), 671 }; 672 673 static int __init ipip_init(void) 674 { 675 int err; 676 677 pr_info("ipip: IPv4 and MPLS over IPv4 tunneling driver\n"); 678 679 err = register_pernet_device(&ipip_net_ops); 680 if (err < 0) 681 return err; 682 err = xfrm4_tunnel_register(&ipip_handler, AF_INET); 683 if (err < 0) { 684 pr_info("%s: can't register tunnel\n", __func__); 685 goto xfrm_tunnel_ipip_failed; 686 } 687 #if IS_ENABLED(CONFIG_MPLS) 688 err = xfrm4_tunnel_register(&mplsip_handler, AF_MPLS); 689 if (err < 0) { 690 pr_info("%s: can't register tunnel\n", __func__); 691 goto xfrm_tunnel_mplsip_failed; 692 } 693 #endif 694 err = rtnl_link_register(&ipip_link_ops); 695 if (err < 0) 696 goto rtnl_link_failed; 697 698 out: 699 return err; 700 701 rtnl_link_failed: 702 #if IS_ENABLED(CONFIG_MPLS) 703 xfrm4_tunnel_deregister(&mplsip_handler, AF_INET); 704 xfrm_tunnel_mplsip_failed: 705 706 #endif 707 xfrm4_tunnel_deregister(&ipip_handler, AF_INET); 708 xfrm_tunnel_ipip_failed: 709 unregister_pernet_device(&ipip_net_ops); 710 goto out; 711 } 712 713 static void __exit ipip_fini(void) 714 { 715 rtnl_link_unregister(&ipip_link_ops); 716 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET)) 717 pr_info("%s: can't deregister tunnel\n", __func__); 718 #if IS_ENABLED(CONFIG_MPLS) 719 if (xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS)) 720 pr_info("%s: can't deregister tunnel\n", __func__); 721 #endif 722 unregister_pernet_device(&ipip_net_ops); 723 } 724 725 module_init(ipip_init); 726 module_exit(ipip_fini); 727 MODULE_LICENSE("GPL"); 728 MODULE_ALIAS_RTNL_LINK("ipip"); 729 MODULE_ALIAS_NETDEV("tunl0"); 730