Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/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/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 
119 static bool log_ecn_error = true;
120 module_param(log_ecn_error, bool, 0644);
121 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
122 
123 static int ipip_net_id __read_mostly;
124 
125 static int ipip_tunnel_init(struct net_device *dev);
126 static struct rtnl_link_ops ipip_link_ops __read_mostly;
127 
128 static int ipip_err(struct sk_buff *skb, u32 info)
129 {
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         struct ip_tunnel *t;
139         int err;
140         const int type = icmp_hdr(skb)->type;
141         const int code = icmp_hdr(skb)->code;
142 
143         err = -ENOENT;
144         t = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
145                              iph->daddr, iph->saddr, 0);
146         if (!t)
147                 goto out;
148 
149         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
150                 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
151                                  t->parms.link, 0, iph->protocol, 0);
152                 err = 0;
153                 goto out;
154         }
155 
156         if (type == ICMP_REDIRECT) {
157                 ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
158                               iph->protocol, 0);
159                 err = 0;
160                 goto out;
161         }
162 
163         if (t->parms.iph.daddr == 0)
164                 goto out;
165 
166         err = 0;
167         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
168                 goto out;
169 
170         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
171                 t->err_count++;
172         else
173                 t->err_count = 1;
174         t->err_time = jiffies;
175 
176 out:
177         return err;
178 }
179 
180 static const struct tnl_ptk_info ipip_tpi = {
181         /* no tunnel info required for ipip. */
182         .proto = htons(ETH_P_IP),
183 };
184 
185 #if IS_ENABLED(CONFIG_MPLS)
186 static const struct tnl_ptk_info mplsip_tpi = {
187         /* no tunnel info required for mplsip. */
188         .proto = htons(ETH_P_MPLS_UC),
189 };
190 #endif
191 
192 static int ipip_tunnel_rcv(struct sk_buff *skb, u8 ipproto)
193 {
194         struct net *net = dev_net(skb->dev);
195         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
196         struct ip_tunnel *tunnel;
197         const struct iphdr *iph;
198 
199         iph = ip_hdr(skb);
200         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
201                         iph->saddr, iph->daddr, 0);
202         if (tunnel) {
203                 const struct tnl_ptk_info *tpi;
204 
205                 if (tunnel->parms.iph.protocol != ipproto &&
206                     tunnel->parms.iph.protocol != 0)
207                         goto drop;
208 
209                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
210                         goto drop;
211 #if IS_ENABLED(CONFIG_MPLS)
212                 if (ipproto == IPPROTO_MPLS)
213                         tpi = &mplsip_tpi;
214                 else
215 #endif
216                         tpi = &ipip_tpi;
217                 if (iptunnel_pull_header(skb, 0, tpi->proto, false))
218                         goto drop;
219                 return ip_tunnel_rcv(tunnel, skb, tpi, NULL, log_ecn_error);
220         }
221 
222         return -1;
223 
224 drop:
225         kfree_skb(skb);
226         return 0;
227 }
228 
229 static int ipip_rcv(struct sk_buff *skb)
230 {
231         return ipip_tunnel_rcv(skb, IPPROTO_IPIP);
232 }
233 
234 #if IS_ENABLED(CONFIG_MPLS)
235 static int mplsip_rcv(struct sk_buff *skb)
236 {
237         return ipip_tunnel_rcv(skb, IPPROTO_MPLS);
238 }
239 #endif
240 
241 /*
242  *      This function assumes it is being called from dev_queue_xmit()
243  *      and that skb is filled properly by that function.
244  */
245 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb,
246                                     struct net_device *dev)
247 {
248         struct ip_tunnel *tunnel = netdev_priv(dev);
249         const struct iphdr  *tiph = &tunnel->parms.iph;
250         u8 ipproto;
251 
252         switch (skb->protocol) {
253         case htons(ETH_P_IP):
254                 ipproto = IPPROTO_IPIP;
255                 break;
256 #if IS_ENABLED(CONFIG_MPLS)
257         case htons(ETH_P_MPLS_UC):
258                 ipproto = IPPROTO_MPLS;
259                 break;
260 #endif
261         default:
262                 goto tx_error;
263         }
264 
265         if (tiph->protocol != ipproto && tiph->protocol != 0)
266                 goto tx_error;
267 
268         if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4))
269                 goto tx_error;
270 
271         skb_set_inner_ipproto(skb, ipproto);
272 
273         ip_tunnel_xmit(skb, dev, tiph, ipproto);
274         return NETDEV_TX_OK;
275 
276 tx_error:
277         kfree_skb(skb);
278 
279         dev->stats.tx_errors++;
280         return NETDEV_TX_OK;
281 }
282 
283 static bool ipip_tunnel_ioctl_verify_protocol(u8 ipproto)
284 {
285         switch (ipproto) {
286         case 0:
287         case IPPROTO_IPIP:
288 #if IS_ENABLED(CONFIG_MPLS)
289         case IPPROTO_MPLS:
290 #endif
291                 return true;
292         }
293 
294         return false;
295 }
296 
297 static int
298 ipip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
299 {
300         int err = 0;
301         struct ip_tunnel_parm p;
302 
303         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
304                 return -EFAULT;
305 
306         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
307                 if (p.iph.version != 4 ||
308                     !ipip_tunnel_ioctl_verify_protocol(p.iph.protocol) ||
309                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
310                         return -EINVAL;
311         }
312 
313         p.i_key = p.o_key = 0;
314         p.i_flags = p.o_flags = 0;
315         err = ip_tunnel_ioctl(dev, &p, cmd);
316         if (err)
317                 return err;
318 
319         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
320                 return -EFAULT;
321 
322         return 0;
323 }
324 
325 static const struct net_device_ops ipip_netdev_ops = {
326         .ndo_init       = ipip_tunnel_init,
327         .ndo_uninit     = ip_tunnel_uninit,
328         .ndo_start_xmit = ipip_tunnel_xmit,
329         .ndo_do_ioctl   = ipip_tunnel_ioctl,
330         .ndo_change_mtu = ip_tunnel_change_mtu,
331         .ndo_get_stats64 = ip_tunnel_get_stats64,
332         .ndo_get_iflink = ip_tunnel_get_iflink,
333 };
334 
335 #define IPIP_FEATURES (NETIF_F_SG |             \
336                        NETIF_F_FRAGLIST |       \
337                        NETIF_F_HIGHDMA |        \
338                        NETIF_F_GSO_SOFTWARE |   \
339                        NETIF_F_HW_CSUM)
340 
341 static void ipip_tunnel_setup(struct net_device *dev)
342 {
343         dev->netdev_ops         = &ipip_netdev_ops;
344 
345         dev->type               = ARPHRD_TUNNEL;
346         dev->flags              = IFF_NOARP;
347         dev->addr_len           = 4;
348         dev->features           |= NETIF_F_LLTX;
349         netif_keep_dst(dev);
350 
351         dev->features           |= IPIP_FEATURES;
352         dev->hw_features        |= IPIP_FEATURES;
353         ip_tunnel_setup(dev, ipip_net_id);
354 }
355 
356 static int ipip_tunnel_init(struct net_device *dev)
357 {
358         struct ip_tunnel *tunnel = netdev_priv(dev);
359 
360         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
361         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
362 
363         tunnel->tun_hlen = 0;
364         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
365         return ip_tunnel_init(dev);
366 }
367 
368 static int ipip_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
369 {
370         u8 proto;
371 
372         if (!data || !data[IFLA_IPTUN_PROTO])
373                 return 0;
374 
375         proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
376         if (proto != IPPROTO_IPIP && proto != IPPROTO_MPLS && proto != 0)
377                 return -EINVAL;
378 
379         return 0;
380 }
381 
382 static void ipip_netlink_parms(struct nlattr *data[],
383                                struct ip_tunnel_parm *parms)
384 {
385         memset(parms, 0, sizeof(*parms));
386 
387         parms->iph.version = 4;
388         parms->iph.protocol = IPPROTO_IPIP;
389         parms->iph.ihl = 5;
390 
391         if (!data)
392                 return;
393 
394         if (data[IFLA_IPTUN_LINK])
395                 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
396 
397         if (data[IFLA_IPTUN_LOCAL])
398                 parms->iph.saddr = nla_get_in_addr(data[IFLA_IPTUN_LOCAL]);
399 
400         if (data[IFLA_IPTUN_REMOTE])
401                 parms->iph.daddr = nla_get_in_addr(data[IFLA_IPTUN_REMOTE]);
402 
403         if (data[IFLA_IPTUN_TTL]) {
404                 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
405                 if (parms->iph.ttl)
406                         parms->iph.frag_off = htons(IP_DF);
407         }
408 
409         if (data[IFLA_IPTUN_TOS])
410                 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
411 
412         if (data[IFLA_IPTUN_PROTO])
413                 parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
414 
415         if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
416                 parms->iph.frag_off = htons(IP_DF);
417 }
418 
419 /* This function returns true when ENCAP attributes are present in the nl msg */
420 static bool ipip_netlink_encap_parms(struct nlattr *data[],
421                                      struct ip_tunnel_encap *ipencap)
422 {
423         bool ret = false;
424 
425         memset(ipencap, 0, sizeof(*ipencap));
426 
427         if (!data)
428                 return ret;
429 
430         if (data[IFLA_IPTUN_ENCAP_TYPE]) {
431                 ret = true;
432                 ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
433         }
434 
435         if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
436                 ret = true;
437                 ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
438         }
439 
440         if (data[IFLA_IPTUN_ENCAP_SPORT]) {
441                 ret = true;
442                 ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
443         }
444 
445         if (data[IFLA_IPTUN_ENCAP_DPORT]) {
446                 ret = true;
447                 ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
448         }
449 
450         return ret;
451 }
452 
453 static int ipip_newlink(struct net *src_net, struct net_device *dev,
454                         struct nlattr *tb[], struct nlattr *data[])
455 {
456         struct ip_tunnel_parm p;
457         struct ip_tunnel_encap ipencap;
458 
459         if (ipip_netlink_encap_parms(data, &ipencap)) {
460                 struct ip_tunnel *t = netdev_priv(dev);
461                 int err = ip_tunnel_encap_setup(t, &ipencap);
462 
463                 if (err < 0)
464                         return err;
465         }
466 
467         ipip_netlink_parms(data, &p);
468         return ip_tunnel_newlink(dev, tb, &p);
469 }
470 
471 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
472                            struct nlattr *data[])
473 {
474         struct ip_tunnel_parm p;
475         struct ip_tunnel_encap ipencap;
476 
477         if (ipip_netlink_encap_parms(data, &ipencap)) {
478                 struct ip_tunnel *t = netdev_priv(dev);
479                 int err = ip_tunnel_encap_setup(t, &ipencap);
480 
481                 if (err < 0)
482                         return err;
483         }
484 
485         ipip_netlink_parms(data, &p);
486 
487         if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
488             (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
489                 return -EINVAL;
490 
491         return ip_tunnel_changelink(dev, tb, &p);
492 }
493 
494 static size_t ipip_get_size(const struct net_device *dev)
495 {
496         return
497                 /* IFLA_IPTUN_LINK */
498                 nla_total_size(4) +
499                 /* IFLA_IPTUN_LOCAL */
500                 nla_total_size(4) +
501                 /* IFLA_IPTUN_REMOTE */
502                 nla_total_size(4) +
503                 /* IFLA_IPTUN_TTL */
504                 nla_total_size(1) +
505                 /* IFLA_IPTUN_TOS */
506                 nla_total_size(1) +
507                 /* IFLA_IPTUN_PROTO */
508                 nla_total_size(1) +
509                 /* IFLA_IPTUN_PMTUDISC */
510                 nla_total_size(1) +
511                 /* IFLA_IPTUN_ENCAP_TYPE */
512                 nla_total_size(2) +
513                 /* IFLA_IPTUN_ENCAP_FLAGS */
514                 nla_total_size(2) +
515                 /* IFLA_IPTUN_ENCAP_SPORT */
516                 nla_total_size(2) +
517                 /* IFLA_IPTUN_ENCAP_DPORT */
518                 nla_total_size(2) +
519                 0;
520 }
521 
522 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
523 {
524         struct ip_tunnel *tunnel = netdev_priv(dev);
525         struct ip_tunnel_parm *parm = &tunnel->parms;
526 
527         if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
528             nla_put_in_addr(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
529             nla_put_in_addr(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
530             nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
531             nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
532             nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
533             nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
534                        !!(parm->iph.frag_off & htons(IP_DF))))
535                 goto nla_put_failure;
536 
537         if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
538                         tunnel->encap.type) ||
539             nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
540                          tunnel->encap.sport) ||
541             nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
542                          tunnel->encap.dport) ||
543             nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
544                         tunnel->encap.flags))
545                 goto nla_put_failure;
546 
547         return 0;
548 
549 nla_put_failure:
550         return -EMSGSIZE;
551 }
552 
553 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
554         [IFLA_IPTUN_LINK]               = { .type = NLA_U32 },
555         [IFLA_IPTUN_LOCAL]              = { .type = NLA_U32 },
556         [IFLA_IPTUN_REMOTE]             = { .type = NLA_U32 },
557         [IFLA_IPTUN_TTL]                = { .type = NLA_U8 },
558         [IFLA_IPTUN_TOS]                = { .type = NLA_U8 },
559         [IFLA_IPTUN_PROTO]              = { .type = NLA_U8 },
560         [IFLA_IPTUN_PMTUDISC]           = { .type = NLA_U8 },
561         [IFLA_IPTUN_ENCAP_TYPE]         = { .type = NLA_U16 },
562         [IFLA_IPTUN_ENCAP_FLAGS]        = { .type = NLA_U16 },
563         [IFLA_IPTUN_ENCAP_SPORT]        = { .type = NLA_U16 },
564         [IFLA_IPTUN_ENCAP_DPORT]        = { .type = NLA_U16 },
565 };
566 
567 static struct rtnl_link_ops ipip_link_ops __read_mostly = {
568         .kind           = "ipip",
569         .maxtype        = IFLA_IPTUN_MAX,
570         .policy         = ipip_policy,
571         .priv_size      = sizeof(struct ip_tunnel),
572         .setup          = ipip_tunnel_setup,
573         .validate       = ipip_tunnel_validate,
574         .newlink        = ipip_newlink,
575         .changelink     = ipip_changelink,
576         .dellink        = ip_tunnel_dellink,
577         .get_size       = ipip_get_size,
578         .fill_info      = ipip_fill_info,
579         .get_link_net   = ip_tunnel_get_link_net,
580 };
581 
582 static struct xfrm_tunnel ipip_handler __read_mostly = {
583         .handler        =       ipip_rcv,
584         .err_handler    =       ipip_err,
585         .priority       =       1,
586 };
587 
588 #if IS_ENABLED(CONFIG_MPLS)
589 static struct xfrm_tunnel mplsip_handler __read_mostly = {
590         .handler        =       mplsip_rcv,
591         .err_handler    =       ipip_err,
592         .priority       =       1,
593 };
594 #endif
595 
596 static int __net_init ipip_init_net(struct net *net)
597 {
598         return ip_tunnel_init_net(net, ipip_net_id, &ipip_link_ops, "tunl0");
599 }
600 
601 static void __net_exit ipip_exit_net(struct net *net)
602 {
603         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
604         ip_tunnel_delete_net(itn, &ipip_link_ops);
605 }
606 
607 static struct pernet_operations ipip_net_ops = {
608         .init = ipip_init_net,
609         .exit = ipip_exit_net,
610         .id   = &ipip_net_id,
611         .size = sizeof(struct ip_tunnel_net),
612 };
613 
614 static int __init ipip_init(void)
615 {
616         int err;
617 
618         pr_info("ipip: IPv4 and MPLS over IPv4 tunneling driver\n");
619 
620         err = register_pernet_device(&ipip_net_ops);
621         if (err < 0)
622                 return err;
623         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
624         if (err < 0) {
625                 pr_info("%s: can't register tunnel\n", __func__);
626                 goto xfrm_tunnel_ipip_failed;
627         }
628 #if IS_ENABLED(CONFIG_MPLS)
629         err = xfrm4_tunnel_register(&mplsip_handler, AF_MPLS);
630         if (err < 0) {
631                 pr_info("%s: can't register tunnel\n", __func__);
632                 goto xfrm_tunnel_mplsip_failed;
633         }
634 #endif
635         err = rtnl_link_register(&ipip_link_ops);
636         if (err < 0)
637                 goto rtnl_link_failed;
638 
639 out:
640         return err;
641 
642 rtnl_link_failed:
643 #if IS_ENABLED(CONFIG_MPLS)
644         xfrm4_tunnel_deregister(&mplsip_handler, AF_INET);
645 xfrm_tunnel_mplsip_failed:
646 
647 #endif
648         xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
649 xfrm_tunnel_ipip_failed:
650         unregister_pernet_device(&ipip_net_ops);
651         goto out;
652 }
653 
654 static void __exit ipip_fini(void)
655 {
656         rtnl_link_unregister(&ipip_link_ops);
657         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
658                 pr_info("%s: can't deregister tunnel\n", __func__);
659 #if IS_ENABLED(CONFIG_MPLS)
660         if (xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS))
661                 pr_info("%s: can't deregister tunnel\n", __func__);
662 #endif
663         unregister_pernet_device(&ipip_net_ops);
664 }
665 
666 module_init(ipip_init);
667 module_exit(ipip_fini);
668 MODULE_LICENSE("GPL");
669 MODULE_ALIAS_RTNL_LINK("ipip");
670 MODULE_ALIAS_NETDEV("tunl0");
671 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us