]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - net/ipv4/ipip.c
tunnels: Optimize tx path
[linux-2.6.git] / 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 <asm/uaccess.h>
99 #include <linux/skbuff.h>
100 #include <linux/netdevice.h>
101 #include <linux/in.h>
102 #include <linux/tcp.h>
103 #include <linux/udp.h>
104 #include <linux/if_arp.h>
105 #include <linux/mroute.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/ipip.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 #define HASH_SIZE  16
120 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
121
122 static int ipip_net_id;
123 struct ipip_net {
124         struct ip_tunnel *tunnels_r_l[HASH_SIZE];
125         struct ip_tunnel *tunnels_r[HASH_SIZE];
126         struct ip_tunnel *tunnels_l[HASH_SIZE];
127         struct ip_tunnel *tunnels_wc[1];
128         struct ip_tunnel **tunnels[4];
129
130         struct net_device *fb_tunnel_dev;
131 };
132
133 static void ipip_fb_tunnel_init(struct net_device *dev);
134 static void ipip_tunnel_init(struct net_device *dev);
135 static void ipip_tunnel_setup(struct net_device *dev);
136
137 static DEFINE_RWLOCK(ipip_lock);
138
139 static struct ip_tunnel * ipip_tunnel_lookup(struct net *net,
140                 __be32 remote, __be32 local)
141 {
142         unsigned h0 = HASH(remote);
143         unsigned h1 = HASH(local);
144         struct ip_tunnel *t;
145         struct ipip_net *ipn = net_generic(net, ipip_net_id);
146
147         for (t = ipn->tunnels_r_l[h0^h1]; t; t = t->next) {
148                 if (local == t->parms.iph.saddr &&
149                     remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
150                         return t;
151         }
152         for (t = ipn->tunnels_r[h0]; t; t = t->next) {
153                 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
154                         return t;
155         }
156         for (t = ipn->tunnels_l[h1]; t; t = t->next) {
157                 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
158                         return t;
159         }
160         if ((t = ipn->tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
161                 return t;
162         return NULL;
163 }
164
165 static struct ip_tunnel **__ipip_bucket(struct ipip_net *ipn,
166                 struct ip_tunnel_parm *parms)
167 {
168         __be32 remote = parms->iph.daddr;
169         __be32 local = parms->iph.saddr;
170         unsigned h = 0;
171         int prio = 0;
172
173         if (remote) {
174                 prio |= 2;
175                 h ^= HASH(remote);
176         }
177         if (local) {
178                 prio |= 1;
179                 h ^= HASH(local);
180         }
181         return &ipn->tunnels[prio][h];
182 }
183
184 static inline struct ip_tunnel **ipip_bucket(struct ipip_net *ipn,
185                 struct ip_tunnel *t)
186 {
187         return __ipip_bucket(ipn, &t->parms);
188 }
189
190 static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
191 {
192         struct ip_tunnel **tp;
193
194         for (tp = ipip_bucket(ipn, t); *tp; tp = &(*tp)->next) {
195                 if (t == *tp) {
196                         write_lock_bh(&ipip_lock);
197                         *tp = t->next;
198                         write_unlock_bh(&ipip_lock);
199                         break;
200                 }
201         }
202 }
203
204 static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
205 {
206         struct ip_tunnel **tp = ipip_bucket(ipn, t);
207
208         t->next = *tp;
209         write_lock_bh(&ipip_lock);
210         *tp = t;
211         write_unlock_bh(&ipip_lock);
212 }
213
214 static struct ip_tunnel * ipip_tunnel_locate(struct net *net,
215                 struct ip_tunnel_parm *parms, int create)
216 {
217         __be32 remote = parms->iph.daddr;
218         __be32 local = parms->iph.saddr;
219         struct ip_tunnel *t, **tp, *nt;
220         struct net_device *dev;
221         char name[IFNAMSIZ];
222         struct ipip_net *ipn = net_generic(net, ipip_net_id);
223
224         for (tp = __ipip_bucket(ipn, parms); (t = *tp) != NULL; tp = &t->next) {
225                 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
226                         return t;
227         }
228         if (!create)
229                 return NULL;
230
231         if (parms->name[0])
232                 strlcpy(name, parms->name, IFNAMSIZ);
233         else
234                 sprintf(name, "tunl%%d");
235
236         dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
237         if (dev == NULL)
238                 return NULL;
239
240         dev_net_set(dev, net);
241
242         if (strchr(name, '%')) {
243                 if (dev_alloc_name(dev, name) < 0)
244                         goto failed_free;
245         }
246
247         nt = netdev_priv(dev);
248         nt->parms = *parms;
249
250         ipip_tunnel_init(dev);
251
252         if (register_netdevice(dev) < 0)
253                 goto failed_free;
254
255         dev_hold(dev);
256         ipip_tunnel_link(ipn, nt);
257         return nt;
258
259 failed_free:
260         free_netdev(dev);
261         return NULL;
262 }
263
264 static void ipip_tunnel_uninit(struct net_device *dev)
265 {
266         struct net *net = dev_net(dev);
267         struct ipip_net *ipn = net_generic(net, ipip_net_id);
268
269         if (dev == ipn->fb_tunnel_dev) {
270                 write_lock_bh(&ipip_lock);
271                 ipn->tunnels_wc[0] = NULL;
272                 write_unlock_bh(&ipip_lock);
273         } else
274                 ipip_tunnel_unlink(ipn, netdev_priv(dev));
275         dev_put(dev);
276 }
277
278 static int ipip_err(struct sk_buff *skb, u32 info)
279 {
280
281 /* All the routers (except for Linux) return only
282    8 bytes of packet payload. It means, that precise relaying of
283    ICMP in the real Internet is absolutely infeasible.
284  */
285         struct iphdr *iph = (struct iphdr *)skb->data;
286         const int type = icmp_hdr(skb)->type;
287         const int code = icmp_hdr(skb)->code;
288         struct ip_tunnel *t;
289         int err;
290
291         switch (type) {
292         default:
293         case ICMP_PARAMETERPROB:
294                 return 0;
295
296         case ICMP_DEST_UNREACH:
297                 switch (code) {
298                 case ICMP_SR_FAILED:
299                 case ICMP_PORT_UNREACH:
300                         /* Impossible event. */
301                         return 0;
302                 case ICMP_FRAG_NEEDED:
303                         /* Soft state for pmtu is maintained by IP core. */
304                         return 0;
305                 default:
306                         /* All others are translated to HOST_UNREACH.
307                            rfc2003 contains "deep thoughts" about NET_UNREACH,
308                            I believe they are just ether pollution. --ANK
309                          */
310                         break;
311                 }
312                 break;
313         case ICMP_TIME_EXCEEDED:
314                 if (code != ICMP_EXC_TTL)
315                         return 0;
316                 break;
317         }
318
319         err = -ENOENT;
320
321         read_lock(&ipip_lock);
322         t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
323         if (t == NULL || t->parms.iph.daddr == 0)
324                 goto out;
325
326         err = 0;
327         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
328                 goto out;
329
330         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
331                 t->err_count++;
332         else
333                 t->err_count = 1;
334         t->err_time = jiffies;
335 out:
336         read_unlock(&ipip_lock);
337         return err;
338 }
339
340 static inline void ipip_ecn_decapsulate(const struct iphdr *outer_iph,
341                                         struct sk_buff *skb)
342 {
343         struct iphdr *inner_iph = ip_hdr(skb);
344
345         if (INET_ECN_is_ce(outer_iph->tos))
346                 IP_ECN_set_ce(inner_iph);
347 }
348
349 static int ipip_rcv(struct sk_buff *skb)
350 {
351         struct ip_tunnel *tunnel;
352         const struct iphdr *iph = ip_hdr(skb);
353
354         read_lock(&ipip_lock);
355         if ((tunnel = ipip_tunnel_lookup(dev_net(skb->dev),
356                                         iph->saddr, iph->daddr)) != NULL) {
357                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
358                         read_unlock(&ipip_lock);
359                         kfree_skb(skb);
360                         return 0;
361                 }
362
363                 secpath_reset(skb);
364
365                 skb->mac_header = skb->network_header;
366                 skb_reset_network_header(skb);
367                 skb->protocol = htons(ETH_P_IP);
368                 skb->pkt_type = PACKET_HOST;
369
370                 tunnel->dev->stats.rx_packets++;
371                 tunnel->dev->stats.rx_bytes += skb->len;
372                 skb->dev = tunnel->dev;
373                 skb_dst_drop(skb);
374                 nf_reset(skb);
375                 ipip_ecn_decapsulate(iph, skb);
376                 netif_rx(skb);
377                 read_unlock(&ipip_lock);
378                 return 0;
379         }
380         read_unlock(&ipip_lock);
381
382         return -1;
383 }
384
385 /*
386  *      This function assumes it is being called from dev_queue_xmit()
387  *      and that skb is filled properly by that function.
388  */
389
390 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
391 {
392         struct ip_tunnel *tunnel = netdev_priv(dev);
393         struct net_device_stats *stats = &dev->stats;
394         struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
395         struct iphdr  *tiph = &tunnel->parms.iph;
396         u8     tos = tunnel->parms.iph.tos;
397         __be16 df = tiph->frag_off;
398         struct rtable *rt;                      /* Route to the other host */
399         struct net_device *tdev;                        /* Device to other host */
400         struct iphdr  *old_iph = ip_hdr(skb);
401         struct iphdr  *iph;                     /* Our new IP header */
402         unsigned int max_headroom;              /* The extra header space needed */
403         __be32 dst = tiph->daddr;
404         int    mtu;
405
406         if (skb->protocol != htons(ETH_P_IP))
407                 goto tx_error;
408
409         if (tos&1)
410                 tos = old_iph->tos;
411
412         if (!dst) {
413                 /* NBMA tunnel */
414                 if ((rt = skb_rtable(skb)) == NULL) {
415                         stats->tx_fifo_errors++;
416                         goto tx_error;
417                 }
418                 if ((dst = rt->rt_gateway) == 0)
419                         goto tx_error_icmp;
420         }
421
422         {
423                 struct flowi fl = { .oif = tunnel->parms.link,
424                                     .nl_u = { .ip4_u =
425                                               { .daddr = dst,
426                                                 .saddr = tiph->saddr,
427                                                 .tos = RT_TOS(tos) } },
428                                     .proto = IPPROTO_IPIP };
429                 if (ip_route_output_key(dev_net(dev), &rt, &fl)) {
430                         stats->tx_carrier_errors++;
431                         goto tx_error_icmp;
432                 }
433         }
434         tdev = rt->u.dst.dev;
435
436         if (tdev == dev) {
437                 ip_rt_put(rt);
438                 stats->collisions++;
439                 goto tx_error;
440         }
441
442         if (tiph->frag_off)
443                 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
444         else
445                 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
446
447         if (mtu < 68) {
448                 stats->collisions++;
449                 ip_rt_put(rt);
450                 goto tx_error;
451         }
452         if (skb_dst(skb))
453                 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
454
455         df |= (old_iph->frag_off&htons(IP_DF));
456
457         if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
458                 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
459                 ip_rt_put(rt);
460                 goto tx_error;
461         }
462
463         if (tunnel->err_count > 0) {
464                 if (time_before(jiffies,
465                                 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
466                         tunnel->err_count--;
467                         dst_link_failure(skb);
468                 } else
469                         tunnel->err_count = 0;
470         }
471
472         /*
473          * Okay, now see if we can stuff it in the buffer as-is.
474          */
475         max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
476
477         if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
478             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
479                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
480                 if (!new_skb) {
481                         ip_rt_put(rt);
482                         txq->tx_dropped++;
483                         dev_kfree_skb(skb);
484                         return NETDEV_TX_OK;
485                 }
486                 if (skb->sk)
487                         skb_set_owner_w(new_skb, skb->sk);
488                 dev_kfree_skb(skb);
489                 skb = new_skb;
490                 old_iph = ip_hdr(skb);
491         }
492
493         skb->transport_header = skb->network_header;
494         skb_push(skb, sizeof(struct iphdr));
495         skb_reset_network_header(skb);
496         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
497         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
498                               IPSKB_REROUTED);
499         skb_dst_drop(skb);
500         skb_dst_set(skb, &rt->u.dst);
501
502         /*
503          *      Push down and install the IPIP header.
504          */
505
506         iph                     =       ip_hdr(skb);
507         iph->version            =       4;
508         iph->ihl                =       sizeof(struct iphdr)>>2;
509         iph->frag_off           =       df;
510         iph->protocol           =       IPPROTO_IPIP;
511         iph->tos                =       INET_ECN_encapsulate(tos, old_iph->tos);
512         iph->daddr              =       rt->rt_dst;
513         iph->saddr              =       rt->rt_src;
514
515         if ((iph->ttl = tiph->ttl) == 0)
516                 iph->ttl        =       old_iph->ttl;
517
518         nf_reset(skb);
519
520         IPTUNNEL_XMIT();
521         return NETDEV_TX_OK;
522
523 tx_error_icmp:
524         dst_link_failure(skb);
525 tx_error:
526         stats->tx_errors++;
527         dev_kfree_skb(skb);
528         return NETDEV_TX_OK;
529 }
530
531 static void ipip_tunnel_bind_dev(struct net_device *dev)
532 {
533         struct net_device *tdev = NULL;
534         struct ip_tunnel *tunnel;
535         struct iphdr *iph;
536
537         tunnel = netdev_priv(dev);
538         iph = &tunnel->parms.iph;
539
540         if (iph->daddr) {
541                 struct flowi fl = { .oif = tunnel->parms.link,
542                                     .nl_u = { .ip4_u =
543                                               { .daddr = iph->daddr,
544                                                 .saddr = iph->saddr,
545                                                 .tos = RT_TOS(iph->tos) } },
546                                     .proto = IPPROTO_IPIP };
547                 struct rtable *rt;
548                 if (!ip_route_output_key(dev_net(dev), &rt, &fl)) {
549                         tdev = rt->u.dst.dev;
550                         ip_rt_put(rt);
551                 }
552                 dev->flags |= IFF_POINTOPOINT;
553         }
554
555         if (!tdev && tunnel->parms.link)
556                 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
557
558         if (tdev) {
559                 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
560                 dev->mtu = tdev->mtu - sizeof(struct iphdr);
561         }
562         dev->iflink = tunnel->parms.link;
563 }
564
565 static int
566 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
567 {
568         int err = 0;
569         struct ip_tunnel_parm p;
570         struct ip_tunnel *t;
571         struct net *net = dev_net(dev);
572         struct ipip_net *ipn = net_generic(net, ipip_net_id);
573
574         switch (cmd) {
575         case SIOCGETTUNNEL:
576                 t = NULL;
577                 if (dev == ipn->fb_tunnel_dev) {
578                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
579                                 err = -EFAULT;
580                                 break;
581                         }
582                         t = ipip_tunnel_locate(net, &p, 0);
583                 }
584                 if (t == NULL)
585                         t = netdev_priv(dev);
586                 memcpy(&p, &t->parms, sizeof(p));
587                 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
588                         err = -EFAULT;
589                 break;
590
591         case SIOCADDTUNNEL:
592         case SIOCCHGTUNNEL:
593                 err = -EPERM;
594                 if (!capable(CAP_NET_ADMIN))
595                         goto done;
596
597                 err = -EFAULT;
598                 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
599                         goto done;
600
601                 err = -EINVAL;
602                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
603                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
604                         goto done;
605                 if (p.iph.ttl)
606                         p.iph.frag_off |= htons(IP_DF);
607
608                 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
609
610                 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
611                         if (t != NULL) {
612                                 if (t->dev != dev) {
613                                         err = -EEXIST;
614                                         break;
615                                 }
616                         } else {
617                                 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
618                                     (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
619                                         err = -EINVAL;
620                                         break;
621                                 }
622                                 t = netdev_priv(dev);
623                                 ipip_tunnel_unlink(ipn, t);
624                                 t->parms.iph.saddr = p.iph.saddr;
625                                 t->parms.iph.daddr = p.iph.daddr;
626                                 memcpy(dev->dev_addr, &p.iph.saddr, 4);
627                                 memcpy(dev->broadcast, &p.iph.daddr, 4);
628                                 ipip_tunnel_link(ipn, t);
629                                 netdev_state_change(dev);
630                         }
631                 }
632
633                 if (t) {
634                         err = 0;
635                         if (cmd == SIOCCHGTUNNEL) {
636                                 t->parms.iph.ttl = p.iph.ttl;
637                                 t->parms.iph.tos = p.iph.tos;
638                                 t->parms.iph.frag_off = p.iph.frag_off;
639                                 if (t->parms.link != p.link) {
640                                         t->parms.link = p.link;
641                                         ipip_tunnel_bind_dev(dev);
642                                         netdev_state_change(dev);
643                                 }
644                         }
645                         if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
646                                 err = -EFAULT;
647                 } else
648                         err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
649                 break;
650
651         case SIOCDELTUNNEL:
652                 err = -EPERM;
653                 if (!capable(CAP_NET_ADMIN))
654                         goto done;
655
656                 if (dev == ipn->fb_tunnel_dev) {
657                         err = -EFAULT;
658                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
659                                 goto done;
660                         err = -ENOENT;
661                         if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
662                                 goto done;
663                         err = -EPERM;
664                         if (t->dev == ipn->fb_tunnel_dev)
665                                 goto done;
666                         dev = t->dev;
667                 }
668                 unregister_netdevice(dev);
669                 err = 0;
670                 break;
671
672         default:
673                 err = -EINVAL;
674         }
675
676 done:
677         return err;
678 }
679
680 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
681 {
682         if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
683                 return -EINVAL;
684         dev->mtu = new_mtu;
685         return 0;
686 }
687
688 static const struct net_device_ops ipip_netdev_ops = {
689         .ndo_uninit     = ipip_tunnel_uninit,
690         .ndo_start_xmit = ipip_tunnel_xmit,
691         .ndo_do_ioctl   = ipip_tunnel_ioctl,
692         .ndo_change_mtu = ipip_tunnel_change_mtu,
693
694 };
695
696 static void ipip_tunnel_setup(struct net_device *dev)
697 {
698         dev->netdev_ops         = &ipip_netdev_ops;
699         dev->destructor         = free_netdev;
700
701         dev->type               = ARPHRD_TUNNEL;
702         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr);
703         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr);
704         dev->flags              = IFF_NOARP;
705         dev->iflink             = 0;
706         dev->addr_len           = 4;
707         dev->features           |= NETIF_F_NETNS_LOCAL;
708         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
709 }
710
711 static void ipip_tunnel_init(struct net_device *dev)
712 {
713         struct ip_tunnel *tunnel = netdev_priv(dev);
714
715         tunnel->dev = dev;
716         strcpy(tunnel->parms.name, dev->name);
717
718         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
719         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
720
721         ipip_tunnel_bind_dev(dev);
722 }
723
724 static void ipip_fb_tunnel_init(struct net_device *dev)
725 {
726         struct ip_tunnel *tunnel = netdev_priv(dev);
727         struct iphdr *iph = &tunnel->parms.iph;
728         struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
729
730         tunnel->dev = dev;
731         strcpy(tunnel->parms.name, dev->name);
732
733         iph->version            = 4;
734         iph->protocol           = IPPROTO_IPIP;
735         iph->ihl                = 5;
736
737         dev_hold(dev);
738         ipn->tunnels_wc[0]      = tunnel;
739 }
740
741 static struct xfrm_tunnel ipip_handler = {
742         .handler        =       ipip_rcv,
743         .err_handler    =       ipip_err,
744         .priority       =       1,
745 };
746
747 static const char banner[] __initconst =
748         KERN_INFO "IPv4 over IPv4 tunneling driver\n";
749
750 static void ipip_destroy_tunnels(struct ipip_net *ipn)
751 {
752         int prio;
753
754         for (prio = 1; prio < 4; prio++) {
755                 int h;
756                 for (h = 0; h < HASH_SIZE; h++) {
757                         struct ip_tunnel *t;
758                         while ((t = ipn->tunnels[prio][h]) != NULL)
759                                 unregister_netdevice(t->dev);
760                 }
761         }
762 }
763
764 static int ipip_init_net(struct net *net)
765 {
766         int err;
767         struct ipip_net *ipn;
768
769         err = -ENOMEM;
770         ipn = kzalloc(sizeof(struct ipip_net), GFP_KERNEL);
771         if (ipn == NULL)
772                 goto err_alloc;
773
774         err = net_assign_generic(net, ipip_net_id, ipn);
775         if (err < 0)
776                 goto err_assign;
777
778         ipn->tunnels[0] = ipn->tunnels_wc;
779         ipn->tunnels[1] = ipn->tunnels_l;
780         ipn->tunnels[2] = ipn->tunnels_r;
781         ipn->tunnels[3] = ipn->tunnels_r_l;
782
783         ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
784                                            "tunl0",
785                                            ipip_tunnel_setup);
786         if (!ipn->fb_tunnel_dev) {
787                 err = -ENOMEM;
788                 goto err_alloc_dev;
789         }
790         dev_net_set(ipn->fb_tunnel_dev, net);
791
792         ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
793
794         if ((err = register_netdev(ipn->fb_tunnel_dev)))
795                 goto err_reg_dev;
796
797         return 0;
798
799 err_reg_dev:
800         free_netdev(ipn->fb_tunnel_dev);
801 err_alloc_dev:
802         /* nothing */
803 err_assign:
804         kfree(ipn);
805 err_alloc:
806         return err;
807 }
808
809 static void ipip_exit_net(struct net *net)
810 {
811         struct ipip_net *ipn;
812
813         ipn = net_generic(net, ipip_net_id);
814         rtnl_lock();
815         ipip_destroy_tunnels(ipn);
816         unregister_netdevice(ipn->fb_tunnel_dev);
817         rtnl_unlock();
818         kfree(ipn);
819 }
820
821 static struct pernet_operations ipip_net_ops = {
822         .init = ipip_init_net,
823         .exit = ipip_exit_net,
824 };
825
826 static int __init ipip_init(void)
827 {
828         int err;
829
830         printk(banner);
831
832         if (xfrm4_tunnel_register(&ipip_handler, AF_INET)) {
833                 printk(KERN_INFO "ipip init: can't register tunnel\n");
834                 return -EAGAIN;
835         }
836
837         err = register_pernet_gen_device(&ipip_net_id, &ipip_net_ops);
838         if (err)
839                 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
840
841         return err;
842 }
843
844 static void __exit ipip_fini(void)
845 {
846         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
847                 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
848
849         unregister_pernet_gen_device(ipip_net_id, &ipip_net_ops);
850 }
851
852 module_init(ipip_init);
853 module_exit(ipip_fini);
854 MODULE_LICENSE("GPL");