net/ipv4/ipip.c

   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 <asm/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/mroute.h>
 107 #include <linux/init.h>
 108 #include <linux/netfilter_ipv4.h>
 109 #include <linux/if_ether.h>
 110
 111 #include <net/sock.h>
 112 #include <net/ip.h>
 113 #include <net/icmp.h>
 114 #include <net/ip_tunnels.h>
 115 #include <net/inet_ecn.h>
 116 #include <net/xfrm.h>
 117 #include <net/net_namespace.h>
 118 #include <net/netns/generic.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 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
 132         /* All the routers (except for Linux) return only
 133            8 bytes of packet payload. It means, that precise relaying of
 134            ICMP in the real Internet is absolutely infeasible.
 135          */
 136         struct net *net = dev_net(skb->dev);
 137         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
 138         const struct iphdr *iph = (const struct iphdr *)skb->data;
 139         const int type = icmp_hdr(skb)->type;
 140         const int code = icmp_hdr(skb)->code;
 141         struct ip_tunnel *t;
 142         int err = 0;
 143
 144         switch (type) {
 145         case ICMP_DEST_UNREACH:
 146                 switch (code) {
 147                 case ICMP_SR_FAILED:
 148                         /* Impossible event. */
 149                         goto out;
 150                 default:
 151                         /* All others are translated to HOST_UNREACH.
 152                          * rfc2003 contains "deep thoughts" about NET_UNREACH,
 153                          * I believe they are just ether pollution. --ANK
 154                          */
 155                         break;
 156                 }
 157                 break;
 158
 159         case ICMP_TIME_EXCEEDED:
 160                 if (code != ICMP_EXC_TTL)
 161                         goto out;
 162                 break;
 163
 164         case ICMP_REDIRECT:
 165                 break;
 166
 167         default:
 168                 goto out;
 169         }
 170
 171         t = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
 172                              iph->daddr, iph->saddr, 0);
 173         if (!t) {
 174                 err = -ENOENT;
 175                 goto out;
 176         }
 177
 178         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 179                 ipv4_update_pmtu(skb, net, info, t->parms.link, 0,
 180                                  iph->protocol, 0);
 181                 goto out;
 182         }
 183
 184         if (type == ICMP_REDIRECT) {
 185                 ipv4_redirect(skb, net, t->parms.link, 0, iph->protocol, 0);
 186                 goto out;
 187         }
 188
 189         if (t->parms.iph.daddr == 0) {
 190                 err = -ENOENT;
 191                 goto out;
 192         }
 193
 194         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 195                 goto out;
 196
 197         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 198                 t->err_count++;
 199         else
 200                 t->err_count = 1;
 201         t->err_time = jiffies;
 202
 203 out:
 204         return err;
 205 }
 206
 207 static const struct tnl_ptk_info tpi = {
 208         /* no tunnel info required for ipip. */
 209         .proto = htons(ETH_P_IP),
 210 };
 211
 212 static int ipip_rcv(struct sk_buff *skb)
 213 {
 214         struct net *net = dev_net(skb->dev);
 215         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
 216         struct ip_tunnel *tunnel;
 217         const struct iphdr *iph;
 218
 219         iph = ip_hdr(skb);
 220         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
 221                         iph->saddr, iph->daddr, 0);
 222         if (tunnel) {
 223                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 224                         goto drop;
 225                 if (iptunnel_pull_header(skb, 0, tpi.proto))
 226                         goto drop;
 227                 return ip_tunnel_rcv(tunnel, skb, &tpi, NULL, log_ecn_error);
 228         }
 229
 230         return -1;
 231
 232 drop:
 233         kfree_skb(skb);
 234         return 0;
 235 }
 236
 237 /*
 238  *      This function assumes it is being called from dev_queue_xmit()
 239  *      and that skb is filled properly by that function.
 240  */
 241 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 242 {
 243         struct ip_tunnel *tunnel = netdev_priv(dev);
 244         const struct iphdr  *tiph = &tunnel->parms.iph;
 245
 246         if (unlikely(skb->protocol != htons(ETH_P_IP)))
 247                 goto tx_error;
 248
 249         skb = iptunnel_handle_offloads(skb, false, SKB_GSO_IPIP);
 250         if (IS_ERR(skb))
 251                 goto out;
 252
 253         skb_set_inner_ipproto(skb, IPPROTO_IPIP);
 254
 255         ip_tunnel_xmit(skb, dev, tiph, tiph->protocol);
 256         return NETDEV_TX_OK;
 257
 258 tx_error:
 259         kfree_skb(skb);
 260 out:
 261         dev->stats.tx_errors++;
 262         return NETDEV_TX_OK;
 263 }
 264
 265 static int
 266 ipip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 267 {
 268         int err = 0;
 269         struct ip_tunnel_parm p;
 270
 271         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 272                 return -EFAULT;
 273
 274         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 275                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
 276                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 277                         return -EINVAL;
 278         }
 279
 280         p.i_key = p.o_key = 0;
 281         p.i_flags = p.o_flags = 0;
 282         err = ip_tunnel_ioctl(dev, &p, cmd);
 283         if (err)
 284                 return err;
 285
 286         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 287                 return -EFAULT;
 288
 289         return 0;
 290 }
 291
 292 static const struct net_device_ops ipip_netdev_ops = {
 293         .ndo_init       = ipip_tunnel_init,
 294         .ndo_uninit     = ip_tunnel_uninit,
 295         .ndo_start_xmit = ipip_tunnel_xmit,
 296         .ndo_do_ioctl   = ipip_tunnel_ioctl,
 297         .ndo_change_mtu = ip_tunnel_change_mtu,
 298         .ndo_get_stats64 = ip_tunnel_get_stats64,
 299         .ndo_get_iflink = ip_tunnel_get_iflink,
 300 };
 301
 302 #define IPIP_FEATURES (NETIF_F_SG |             \
 303                        NETIF_F_FRAGLIST |       \
 304                        NETIF_F_HIGHDMA |        \
 305                        NETIF_F_GSO_SOFTWARE |   \
 306                        NETIF_F_HW_CSUM)
 307
 308 static void ipip_tunnel_setup(struct net_device *dev)
 309 {
 310         dev->netdev_ops         = &ipip_netdev_ops;
 311
 312         dev->type               = ARPHRD_TUNNEL;
 313         dev->flags              = IFF_NOARP;
 314         dev->addr_len           = 4;
 315         dev->features           |= NETIF_F_LLTX;
 316         netif_keep_dst(dev);
 317
 318         dev->features           |= IPIP_FEATURES;
 319         dev->hw_features        |= IPIP_FEATURES;
 320         ip_tunnel_setup(dev, ipip_net_id);
 321 }
 322
 323 static int ipip_tunnel_init(struct net_device *dev)
 324 {
 325         struct ip_tunnel *tunnel = netdev_priv(dev);
 326
 327         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 328         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 329
 330         tunnel->tun_hlen = 0;
 331         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 332         tunnel->parms.iph.protocol = IPPROTO_IPIP;
 333         return ip_tunnel_init(dev);
 334 }
 335
 336 static void ipip_netlink_parms(struct nlattr *data[],
 337                                struct ip_tunnel_parm *parms)
 338 {
 339         memset(parms, 0, sizeof(*parms));
 340
 341         parms->iph.version = 4;
 342         parms->iph.protocol = IPPROTO_IPIP;
 343         parms->iph.ihl = 5;
 344
 345         if (!data)
 346                 return;
 347
 348         if (data[IFLA_IPTUN_LINK])
 349                 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
 350
 351         if (data[IFLA_IPTUN_LOCAL])
 352                 parms->iph.saddr = nla_get_in_addr(data[IFLA_IPTUN_LOCAL]);
 353
 354         if (data[IFLA_IPTUN_REMOTE])
 355                 parms->iph.daddr = nla_get_in_addr(data[IFLA_IPTUN_REMOTE]);
 356
 357         if (data[IFLA_IPTUN_TTL]) {
 358                 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
 359                 if (parms->iph.ttl)
 360                         parms->iph.frag_off = htons(IP_DF);
 361         }
 362
 363         if (data[IFLA_IPTUN_TOS])
 364                 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
 365
 366         if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
 367                 parms->iph.frag_off = htons(IP_DF);
 368 }
 369
 370 /* This function returns true when ENCAP attributes are present in the nl msg */
 371 static bool ipip_netlink_encap_parms(struct nlattr *data[],
 372                                      struct ip_tunnel_encap *ipencap)
 373 {
 374         bool ret = false;
 375
 376         memset(ipencap, 0, sizeof(*ipencap));
 377
 378         if (!data)
 379                 return ret;
 380
 381         if (data[IFLA_IPTUN_ENCAP_TYPE]) {
 382                 ret = true;
 383                 ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
 384         }
 385
 386         if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
 387                 ret = true;
 388                 ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
 389         }
 390
 391         if (data[IFLA_IPTUN_ENCAP_SPORT]) {
 392                 ret = true;
 393                 ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
 394         }
 395
 396         if (data[IFLA_IPTUN_ENCAP_DPORT]) {
 397                 ret = true;
 398                 ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
 399         }
 400
 401         return ret;
 402 }
 403
 404 static int ipip_newlink(struct net *src_net, struct net_device *dev,
 405                         struct nlattr *tb[], struct nlattr *data[])
 406 {
 407         struct ip_tunnel_parm p;
 408         struct ip_tunnel_encap ipencap;
 409
 410         if (ipip_netlink_encap_parms(data, &ipencap)) {
 411                 struct ip_tunnel *t = netdev_priv(dev);
 412                 int err = ip_tunnel_encap_setup(t, &ipencap);
 413
 414                 if (err < 0)
 415                         return err;
 416         }
 417
 418         ipip_netlink_parms(data, &p);
 419         return ip_tunnel_newlink(dev, tb, &p);
 420 }
 421
 422 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
 423                            struct nlattr *data[])
 424 {
 425         struct ip_tunnel_parm p;
 426         struct ip_tunnel_encap ipencap;
 427
 428         if (ipip_netlink_encap_parms(data, &ipencap)) {
 429                 struct ip_tunnel *t = netdev_priv(dev);
 430                 int err = ip_tunnel_encap_setup(t, &ipencap);
 431
 432                 if (err < 0)
 433                         return err;
 434         }
 435
 436         ipip_netlink_parms(data, &p);
 437
 438         if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
 439             (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
 440                 return -EINVAL;
 441
 442         return ip_tunnel_changelink(dev, tb, &p);
 443 }
 444
 445 static size_t ipip_get_size(const struct net_device *dev)
 446 {
 447         return
 448                 /* IFLA_IPTUN_LINK */
 449                 nla_total_size(4) +
 450                 /* IFLA_IPTUN_LOCAL */
 451                 nla_total_size(4) +
 452                 /* IFLA_IPTUN_REMOTE */
 453                 nla_total_size(4) +
 454                 /* IFLA_IPTUN_TTL */
 455                 nla_total_size(1) +
 456                 /* IFLA_IPTUN_TOS */
 457                 nla_total_size(1) +
 458                 /* IFLA_IPTUN_PMTUDISC */
 459                 nla_total_size(1) +
 460                 /* IFLA_IPTUN_ENCAP_TYPE */
 461                 nla_total_size(2) +
 462                 /* IFLA_IPTUN_ENCAP_FLAGS */
 463                 nla_total_size(2) +
 464                 /* IFLA_IPTUN_ENCAP_SPORT */
 465                 nla_total_size(2) +
 466                 /* IFLA_IPTUN_ENCAP_DPORT */
 467                 nla_total_size(2) +
 468                 0;
 469 }
 470
 471 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
 472 {
 473         struct ip_tunnel *tunnel = netdev_priv(dev);
 474         struct ip_tunnel_parm *parm = &tunnel->parms;
 475
 476         if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
 477             nla_put_in_addr(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
 478             nla_put_in_addr(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
 479             nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
 480             nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
 481             nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
 482                        !!(parm->iph.frag_off & htons(IP_DF))))
 483                 goto nla_put_failure;
 484
 485         if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
 486                         tunnel->encap.type) ||
 487             nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
 488                          tunnel->encap.sport) ||
 489             nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
 490                          tunnel->encap.dport) ||
 491             nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
 492                         tunnel->encap.flags))
 493                 goto nla_put_failure;
 494
 495         return 0;
 496
 497 nla_put_failure:
 498         return -EMSGSIZE;
 499 }
 500
 501 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
 502         [IFLA_IPTUN_LINK]               = { .type = NLA_U32 },
 503         [IFLA_IPTUN_LOCAL]              = { .type = NLA_U32 },
 504         [IFLA_IPTUN_REMOTE]             = { .type = NLA_U32 },
 505         [IFLA_IPTUN_TTL]                = { .type = NLA_U8 },
 506         [IFLA_IPTUN_TOS]                = { .type = NLA_U8 },
 507         [IFLA_IPTUN_PMTUDISC]           = { .type = NLA_U8 },
 508         [IFLA_IPTUN_ENCAP_TYPE]         = { .type = NLA_U16 },
 509         [IFLA_IPTUN_ENCAP_FLAGS]        = { .type = NLA_U16 },
 510         [IFLA_IPTUN_ENCAP_SPORT]        = { .type = NLA_U16 },
 511         [IFLA_IPTUN_ENCAP_DPORT]        = { .type = NLA_U16 },
 512 };
 513
 514 static struct rtnl_link_ops ipip_link_ops __read_mostly = {
 515         .kind           = "ipip",
 516         .maxtype        = IFLA_IPTUN_MAX,
 517         .policy         = ipip_policy,
 518         .priv_size      = sizeof(struct ip_tunnel),
 519         .setup          = ipip_tunnel_setup,
 520         .newlink        = ipip_newlink,
 521         .changelink     = ipip_changelink,
 522         .dellink        = ip_tunnel_dellink,
 523         .get_size       = ipip_get_size,
 524         .fill_info      = ipip_fill_info,
 525         .get_link_net   = ip_tunnel_get_link_net,
 526 };
 527
 528 static struct xfrm_tunnel ipip_handler __read_mostly = {
 529         .handler        =       ipip_rcv,
 530         .err_handler    =       ipip_err,
 531         .priority       =       1,
 532 };
 533
 534 static int __net_init ipip_init_net(struct net *net)
 535 {
 536         return ip_tunnel_init_net(net, ipip_net_id, &ipip_link_ops, "tunl0");
 537 }
 538
 539 static void __net_exit ipip_exit_net(struct net *net)
 540 {
 541         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
 542         ip_tunnel_delete_net(itn, &ipip_link_ops);
 543 }
 544
 545 static struct pernet_operations ipip_net_ops = {
 546         .init = ipip_init_net,
 547         .exit = ipip_exit_net,
 548         .id   = &ipip_net_id,
 549         .size = sizeof(struct ip_tunnel_net),
 550 };
 551
 552 static int __init ipip_init(void)
 553 {
 554         int err;
 555
 556         pr_info("ipip: IPv4 over IPv4 tunneling driver\n");
 557
 558         err = register_pernet_device(&ipip_net_ops);
 559         if (err < 0)
 560                 return err;
 561         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
 562         if (err < 0) {
 563                 pr_info("%s: can't register tunnel\n", __func__);
 564                 goto xfrm_tunnel_failed;
 565         }
 566         err = rtnl_link_register(&ipip_link_ops);
 567         if (err < 0)
 568                 goto rtnl_link_failed;
 569
 570 out:
 571         return err;
 572
 573 rtnl_link_failed:
 574         xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
 575 xfrm_tunnel_failed:
 576         unregister_pernet_device(&ipip_net_ops);
 577         goto out;
 578 }
 579
 580 static void __exit ipip_fini(void)
 581 {
 582         rtnl_link_unregister(&ipip_link_ops);
 583         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
 584                 pr_info("%s: can't deregister tunnel\n", __func__);
 585
 586         unregister_pernet_device(&ipip_net_ops);
 587 }
 588
 589 module_init(ipip_init);
 590 module_exit(ipip_fini);
 591 MODULE_LICENSE("GPL");
 592 MODULE_ALIAS_RTNL_LINK("ipip");
 593 MODULE_ALIAS_NETDEV("tunl0");