ip_gre: include route header_len in max_headroom calculation
[linux-2.6.git] / net / ipv4 / ip_gre.c
1 /*
2  *      Linux NET3:     GRE over IP protocol decoder.
3  *
4  *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
5  *
6  *      This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License
8  *      as published by the Free Software Foundation; either version
9  *      2 of the License, or (at your option) any later version.
10  *
11  */
12
13 #include <linux/capability.h>
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <asm/uaccess.h>
18 #include <linux/skbuff.h>
19 #include <linux/netdevice.h>
20 #include <linux/in.h>
21 #include <linux/tcp.h>
22 #include <linux/udp.h>
23 #include <linux/if_arp.h>
24 #include <linux/mroute.h>
25 #include <linux/init.h>
26 #include <linux/in6.h>
27 #include <linux/inetdevice.h>
28 #include <linux/igmp.h>
29 #include <linux/netfilter_ipv4.h>
30 #include <linux/etherdevice.h>
31 #include <linux/if_ether.h>
32
33 #include <net/sock.h>
34 #include <net/ip.h>
35 #include <net/icmp.h>
36 #include <net/protocol.h>
37 #include <net/ipip.h>
38 #include <net/arp.h>
39 #include <net/checksum.h>
40 #include <net/dsfield.h>
41 #include <net/inet_ecn.h>
42 #include <net/xfrm.h>
43 #include <net/net_namespace.h>
44 #include <net/netns/generic.h>
45 #include <net/rtnetlink.h>
46
47 #ifdef CONFIG_IPV6
48 #include <net/ipv6.h>
49 #include <net/ip6_fib.h>
50 #include <net/ip6_route.h>
51 #endif
52
53 /*
54    Problems & solutions
55    --------------------
56
57    1. The most important issue is detecting local dead loops.
58    They would cause complete host lockup in transmit, which
59    would be "resolved" by stack overflow or, if queueing is enabled,
60    with infinite looping in net_bh.
61
62    We cannot track such dead loops during route installation,
63    it is infeasible task. The most general solutions would be
64    to keep skb->encapsulation counter (sort of local ttl),
65    and silently drop packet when it expires. It is the best
66    solution, but it supposes maintaing new variable in ALL
67    skb, even if no tunneling is used.
68
69    Current solution: HARD_TX_LOCK lock breaks dead loops.
70
71
72
73    2. Networking dead loops would not kill routers, but would really
74    kill network. IP hop limit plays role of "t->recursion" in this case,
75    if we copy it from packet being encapsulated to upper header.
76    It is very good solution, but it introduces two problems:
77
78    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
79      do not work over tunnels.
80    - traceroute does not work. I planned to relay ICMP from tunnel,
81      so that this problem would be solved and traceroute output
82      would even more informative. This idea appeared to be wrong:
83      only Linux complies to rfc1812 now (yes, guys, Linux is the only
84      true router now :-)), all routers (at least, in neighbourhood of mine)
85      return only 8 bytes of payload. It is the end.
86
87    Hence, if we want that OSPF worked or traceroute said something reasonable,
88    we should search for another solution.
89
90    One of them is to parse packet trying to detect inner encapsulation
91    made by our node. It is difficult or even impossible, especially,
92    taking into account fragmentation. TO be short, tt is not solution at all.
93
94    Current solution: The solution was UNEXPECTEDLY SIMPLE.
95    We force DF flag on tunnels with preconfigured hop limit,
96    that is ALL. :-) Well, it does not remove the problem completely,
97    but exponential growth of network traffic is changed to linear
98    (branches, that exceed pmtu are pruned) and tunnel mtu
99    fastly degrades to value <68, where looping stops.
100    Yes, it is not good if there exists a router in the loop,
101    which does not force DF, even when encapsulating packets have DF set.
102    But it is not our problem! Nobody could accuse us, we made
103    all that we could make. Even if it is your gated who injected
104    fatal route to network, even if it were you who configured
105    fatal static route: you are innocent. :-)
106
107
108
109    3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
110    practically identical code. It would be good to glue them
111    together, but it is not very evident, how to make them modular.
112    sit is integral part of IPv6, ipip and gre are naturally modular.
113    We could extract common parts (hash table, ioctl etc)
114    to a separate module (ip_tunnel.c).
115
116    Alexey Kuznetsov.
117  */
118
119 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
120 static int ipgre_tunnel_init(struct net_device *dev);
121 static void ipgre_tunnel_setup(struct net_device *dev);
122 static int ipgre_tunnel_bind_dev(struct net_device *dev);
123
124 /* Fallback tunnel: no source, no destination, no key, no options */
125
126 #define HASH_SIZE  16
127
128 static int ipgre_net_id __read_mostly;
129 struct ipgre_net {
130         struct ip_tunnel *tunnels[4][HASH_SIZE];
131
132         struct net_device *fb_tunnel_dev;
133 };
134
135 /* Tunnel hash table */
136
137 /*
138    4 hash tables:
139
140    3: (remote,local)
141    2: (remote,*)
142    1: (*,local)
143    0: (*,*)
144
145    We require exact key match i.e. if a key is present in packet
146    it will match only tunnel with the same key; if it is not present,
147    it will match only keyless tunnel.
148
149    All keysless packets, if not matched configured keyless tunnels
150    will match fallback tunnel.
151  */
152
153 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
154
155 #define tunnels_r_l     tunnels[3]
156 #define tunnels_r       tunnels[2]
157 #define tunnels_l       tunnels[1]
158 #define tunnels_wc      tunnels[0]
159 /*
160  * Locking : hash tables are protected by RCU and a spinlock
161  */
162 static DEFINE_SPINLOCK(ipgre_lock);
163
164 #define for_each_ip_tunnel_rcu(start) \
165         for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
166
167 /* Given src, dst and key, find appropriate for input tunnel. */
168
169 static struct ip_tunnel * ipgre_tunnel_lookup(struct net_device *dev,
170                                               __be32 remote, __be32 local,
171                                               __be32 key, __be16 gre_proto)
172 {
173         struct net *net = dev_net(dev);
174         int link = dev->ifindex;
175         unsigned h0 = HASH(remote);
176         unsigned h1 = HASH(key);
177         struct ip_tunnel *t, *cand = NULL;
178         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
179         int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
180                        ARPHRD_ETHER : ARPHRD_IPGRE;
181         int score, cand_score = 4;
182
183         for_each_ip_tunnel_rcu(ign->tunnels_r_l[h0 ^ h1]) {
184                 if (local != t->parms.iph.saddr ||
185                     remote != t->parms.iph.daddr ||
186                     key != t->parms.i_key ||
187                     !(t->dev->flags & IFF_UP))
188                         continue;
189
190                 if (t->dev->type != ARPHRD_IPGRE &&
191                     t->dev->type != dev_type)
192                         continue;
193
194                 score = 0;
195                 if (t->parms.link != link)
196                         score |= 1;
197                 if (t->dev->type != dev_type)
198                         score |= 2;
199                 if (score == 0)
200                         return t;
201
202                 if (score < cand_score) {
203                         cand = t;
204                         cand_score = score;
205                 }
206         }
207
208         for_each_ip_tunnel_rcu(ign->tunnels_r[h0 ^ h1]) {
209                 if (remote != t->parms.iph.daddr ||
210                     key != t->parms.i_key ||
211                     !(t->dev->flags & IFF_UP))
212                         continue;
213
214                 if (t->dev->type != ARPHRD_IPGRE &&
215                     t->dev->type != dev_type)
216                         continue;
217
218                 score = 0;
219                 if (t->parms.link != link)
220                         score |= 1;
221                 if (t->dev->type != dev_type)
222                         score |= 2;
223                 if (score == 0)
224                         return t;
225
226                 if (score < cand_score) {
227                         cand = t;
228                         cand_score = score;
229                 }
230         }
231
232         for_each_ip_tunnel_rcu(ign->tunnels_l[h1]) {
233                 if ((local != t->parms.iph.saddr &&
234                      (local != t->parms.iph.daddr ||
235                       !ipv4_is_multicast(local))) ||
236                     key != t->parms.i_key ||
237                     !(t->dev->flags & IFF_UP))
238                         continue;
239
240                 if (t->dev->type != ARPHRD_IPGRE &&
241                     t->dev->type != dev_type)
242                         continue;
243
244                 score = 0;
245                 if (t->parms.link != link)
246                         score |= 1;
247                 if (t->dev->type != dev_type)
248                         score |= 2;
249                 if (score == 0)
250                         return t;
251
252                 if (score < cand_score) {
253                         cand = t;
254                         cand_score = score;
255                 }
256         }
257
258         for_each_ip_tunnel_rcu(ign->tunnels_wc[h1]) {
259                 if (t->parms.i_key != key ||
260                     !(t->dev->flags & IFF_UP))
261                         continue;
262
263                 if (t->dev->type != ARPHRD_IPGRE &&
264                     t->dev->type != dev_type)
265                         continue;
266
267                 score = 0;
268                 if (t->parms.link != link)
269                         score |= 1;
270                 if (t->dev->type != dev_type)
271                         score |= 2;
272                 if (score == 0)
273                         return t;
274
275                 if (score < cand_score) {
276                         cand = t;
277                         cand_score = score;
278                 }
279         }
280
281         if (cand != NULL)
282                 return cand;
283
284         dev = ign->fb_tunnel_dev;
285         if (dev->flags & IFF_UP)
286                 return netdev_priv(dev);
287
288         return NULL;
289 }
290
291 static struct ip_tunnel **__ipgre_bucket(struct ipgre_net *ign,
292                 struct ip_tunnel_parm *parms)
293 {
294         __be32 remote = parms->iph.daddr;
295         __be32 local = parms->iph.saddr;
296         __be32 key = parms->i_key;
297         unsigned h = HASH(key);
298         int prio = 0;
299
300         if (local)
301                 prio |= 1;
302         if (remote && !ipv4_is_multicast(remote)) {
303                 prio |= 2;
304                 h ^= HASH(remote);
305         }
306
307         return &ign->tunnels[prio][h];
308 }
309
310 static inline struct ip_tunnel **ipgre_bucket(struct ipgre_net *ign,
311                 struct ip_tunnel *t)
312 {
313         return __ipgre_bucket(ign, &t->parms);
314 }
315
316 static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
317 {
318         struct ip_tunnel **tp = ipgre_bucket(ign, t);
319
320         spin_lock_bh(&ipgre_lock);
321         t->next = *tp;
322         rcu_assign_pointer(*tp, t);
323         spin_unlock_bh(&ipgre_lock);
324 }
325
326 static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
327 {
328         struct ip_tunnel **tp;
329
330         for (tp = ipgre_bucket(ign, t); *tp; tp = &(*tp)->next) {
331                 if (t == *tp) {
332                         spin_lock_bh(&ipgre_lock);
333                         *tp = t->next;
334                         spin_unlock_bh(&ipgre_lock);
335                         break;
336                 }
337         }
338 }
339
340 static struct ip_tunnel *ipgre_tunnel_find(struct net *net,
341                                            struct ip_tunnel_parm *parms,
342                                            int type)
343 {
344         __be32 remote = parms->iph.daddr;
345         __be32 local = parms->iph.saddr;
346         __be32 key = parms->i_key;
347         int link = parms->link;
348         struct ip_tunnel *t, **tp;
349         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
350
351         for (tp = __ipgre_bucket(ign, parms); (t = *tp) != NULL; tp = &t->next)
352                 if (local == t->parms.iph.saddr &&
353                     remote == t->parms.iph.daddr &&
354                     key == t->parms.i_key &&
355                     link == t->parms.link &&
356                     type == t->dev->type)
357                         break;
358
359         return t;
360 }
361
362 static struct ip_tunnel * ipgre_tunnel_locate(struct net *net,
363                 struct ip_tunnel_parm *parms, int create)
364 {
365         struct ip_tunnel *t, *nt;
366         struct net_device *dev;
367         char name[IFNAMSIZ];
368         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
369
370         t = ipgre_tunnel_find(net, parms, ARPHRD_IPGRE);
371         if (t || !create)
372                 return t;
373
374         if (parms->name[0])
375                 strlcpy(name, parms->name, IFNAMSIZ);
376         else
377                 sprintf(name, "gre%%d");
378
379         dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
380         if (!dev)
381           return NULL;
382
383         dev_net_set(dev, net);
384
385         if (strchr(name, '%')) {
386                 if (dev_alloc_name(dev, name) < 0)
387                         goto failed_free;
388         }
389
390         nt = netdev_priv(dev);
391         nt->parms = *parms;
392         dev->rtnl_link_ops = &ipgre_link_ops;
393
394         dev->mtu = ipgre_tunnel_bind_dev(dev);
395
396         if (register_netdevice(dev) < 0)
397                 goto failed_free;
398
399         dev_hold(dev);
400         ipgre_tunnel_link(ign, nt);
401         return nt;
402
403 failed_free:
404         free_netdev(dev);
405         return NULL;
406 }
407
408 static void ipgre_tunnel_uninit(struct net_device *dev)
409 {
410         struct net *net = dev_net(dev);
411         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
412
413         ipgre_tunnel_unlink(ign, netdev_priv(dev));
414         dev_put(dev);
415 }
416
417
418 static void ipgre_err(struct sk_buff *skb, u32 info)
419 {
420
421 /* All the routers (except for Linux) return only
422    8 bytes of packet payload. It means, that precise relaying of
423    ICMP in the real Internet is absolutely infeasible.
424
425    Moreover, Cisco "wise men" put GRE key to the third word
426    in GRE header. It makes impossible maintaining even soft state for keyed
427    GRE tunnels with enabled checksum. Tell them "thank you".
428
429    Well, I wonder, rfc1812 was written by Cisco employee,
430    what the hell these idiots break standrads established
431    by themself???
432  */
433
434         struct iphdr *iph = (struct iphdr *)skb->data;
435         __be16       *p = (__be16*)(skb->data+(iph->ihl<<2));
436         int grehlen = (iph->ihl<<2) + 4;
437         const int type = icmp_hdr(skb)->type;
438         const int code = icmp_hdr(skb)->code;
439         struct ip_tunnel *t;
440         __be16 flags;
441
442         flags = p[0];
443         if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
444                 if (flags&(GRE_VERSION|GRE_ROUTING))
445                         return;
446                 if (flags&GRE_KEY) {
447                         grehlen += 4;
448                         if (flags&GRE_CSUM)
449                                 grehlen += 4;
450                 }
451         }
452
453         /* If only 8 bytes returned, keyed message will be dropped here */
454         if (skb_headlen(skb) < grehlen)
455                 return;
456
457         switch (type) {
458         default:
459         case ICMP_PARAMETERPROB:
460                 return;
461
462         case ICMP_DEST_UNREACH:
463                 switch (code) {
464                 case ICMP_SR_FAILED:
465                 case ICMP_PORT_UNREACH:
466                         /* Impossible event. */
467                         return;
468                 case ICMP_FRAG_NEEDED:
469                         /* Soft state for pmtu is maintained by IP core. */
470                         return;
471                 default:
472                         /* All others are translated to HOST_UNREACH.
473                            rfc2003 contains "deep thoughts" about NET_UNREACH,
474                            I believe they are just ether pollution. --ANK
475                          */
476                         break;
477                 }
478                 break;
479         case ICMP_TIME_EXCEEDED:
480                 if (code != ICMP_EXC_TTL)
481                         return;
482                 break;
483         }
484
485         rcu_read_lock();
486         t = ipgre_tunnel_lookup(skb->dev, iph->daddr, iph->saddr,
487                                 flags & GRE_KEY ?
488                                 *(((__be32 *)p) + (grehlen / 4) - 1) : 0,
489                                 p[1]);
490         if (t == NULL || t->parms.iph.daddr == 0 ||
491             ipv4_is_multicast(t->parms.iph.daddr))
492                 goto out;
493
494         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
495                 goto out;
496
497         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
498                 t->err_count++;
499         else
500                 t->err_count = 1;
501         t->err_time = jiffies;
502 out:
503         rcu_read_unlock();
504         return;
505 }
506
507 static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
508 {
509         if (INET_ECN_is_ce(iph->tos)) {
510                 if (skb->protocol == htons(ETH_P_IP)) {
511                         IP_ECN_set_ce(ip_hdr(skb));
512                 } else if (skb->protocol == htons(ETH_P_IPV6)) {
513                         IP6_ECN_set_ce(ipv6_hdr(skb));
514                 }
515         }
516 }
517
518 static inline u8
519 ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
520 {
521         u8 inner = 0;
522         if (skb->protocol == htons(ETH_P_IP))
523                 inner = old_iph->tos;
524         else if (skb->protocol == htons(ETH_P_IPV6))
525                 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
526         return INET_ECN_encapsulate(tos, inner);
527 }
528
529 static int ipgre_rcv(struct sk_buff *skb)
530 {
531         struct iphdr *iph;
532         u8     *h;
533         __be16    flags;
534         __sum16   csum = 0;
535         __be32 key = 0;
536         u32    seqno = 0;
537         struct ip_tunnel *tunnel;
538         int    offset = 4;
539         __be16 gre_proto;
540         unsigned int len;
541
542         if (!pskb_may_pull(skb, 16))
543                 goto drop_nolock;
544
545         iph = ip_hdr(skb);
546         h = skb->data;
547         flags = *(__be16*)h;
548
549         if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
550                 /* - Version must be 0.
551                    - We do not support routing headers.
552                  */
553                 if (flags&(GRE_VERSION|GRE_ROUTING))
554                         goto drop_nolock;
555
556                 if (flags&GRE_CSUM) {
557                         switch (skb->ip_summed) {
558                         case CHECKSUM_COMPLETE:
559                                 csum = csum_fold(skb->csum);
560                                 if (!csum)
561                                         break;
562                                 /* fall through */
563                         case CHECKSUM_NONE:
564                                 skb->csum = 0;
565                                 csum = __skb_checksum_complete(skb);
566                                 skb->ip_summed = CHECKSUM_COMPLETE;
567                         }
568                         offset += 4;
569                 }
570                 if (flags&GRE_KEY) {
571                         key = *(__be32*)(h + offset);
572                         offset += 4;
573                 }
574                 if (flags&GRE_SEQ) {
575                         seqno = ntohl(*(__be32*)(h + offset));
576                         offset += 4;
577                 }
578         }
579
580         gre_proto = *(__be16 *)(h + 2);
581
582         rcu_read_lock();
583         if ((tunnel = ipgre_tunnel_lookup(skb->dev,
584                                           iph->saddr, iph->daddr, key,
585                                           gre_proto))) {
586                 struct net_device_stats *stats = &tunnel->dev->stats;
587
588                 secpath_reset(skb);
589
590                 skb->protocol = gre_proto;
591                 /* WCCP version 1 and 2 protocol decoding.
592                  * - Change protocol to IP
593                  * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
594                  */
595                 if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
596                         skb->protocol = htons(ETH_P_IP);
597                         if ((*(h + offset) & 0xF0) != 0x40)
598                                 offset += 4;
599                 }
600
601                 skb->mac_header = skb->network_header;
602                 __pskb_pull(skb, offset);
603                 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
604                 skb->pkt_type = PACKET_HOST;
605 #ifdef CONFIG_NET_IPGRE_BROADCAST
606                 if (ipv4_is_multicast(iph->daddr)) {
607                         /* Looped back packet, drop it! */
608                         if (skb_rtable(skb)->fl.iif == 0)
609                                 goto drop;
610                         stats->multicast++;
611                         skb->pkt_type = PACKET_BROADCAST;
612                 }
613 #endif
614
615                 if (((flags&GRE_CSUM) && csum) ||
616                     (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
617                         stats->rx_crc_errors++;
618                         stats->rx_errors++;
619                         goto drop;
620                 }
621                 if (tunnel->parms.i_flags&GRE_SEQ) {
622                         if (!(flags&GRE_SEQ) ||
623                             (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
624                                 stats->rx_fifo_errors++;
625                                 stats->rx_errors++;
626                                 goto drop;
627                         }
628                         tunnel->i_seqno = seqno + 1;
629                 }
630
631                 len = skb->len;
632
633                 /* Warning: All skb pointers will be invalidated! */
634                 if (tunnel->dev->type == ARPHRD_ETHER) {
635                         if (!pskb_may_pull(skb, ETH_HLEN)) {
636                                 stats->rx_length_errors++;
637                                 stats->rx_errors++;
638                                 goto drop;
639                         }
640
641                         iph = ip_hdr(skb);
642                         skb->protocol = eth_type_trans(skb, tunnel->dev);
643                         skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
644                 }
645
646                 stats->rx_packets++;
647                 stats->rx_bytes += len;
648                 skb->dev = tunnel->dev;
649                 skb_dst_drop(skb);
650                 nf_reset(skb);
651
652                 skb_reset_network_header(skb);
653                 ipgre_ecn_decapsulate(iph, skb);
654
655                 netif_rx(skb);
656                 rcu_read_unlock();
657                 return(0);
658         }
659         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
660
661 drop:
662         rcu_read_unlock();
663 drop_nolock:
664         kfree_skb(skb);
665         return(0);
666 }
667
668 static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
669 {
670         struct ip_tunnel *tunnel = netdev_priv(dev);
671         struct net_device_stats *stats = &dev->stats;
672         struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
673         struct iphdr  *old_iph = ip_hdr(skb);
674         struct iphdr  *tiph;
675         u8     tos;
676         __be16 df;
677         struct rtable *rt;                      /* Route to the other host */
678         struct net_device *tdev;                        /* Device to other host */
679         struct iphdr  *iph;                     /* Our new IP header */
680         unsigned int max_headroom;              /* The extra header space needed */
681         int    gre_hlen;
682         __be32 dst;
683         int    mtu;
684
685         if (dev->type == ARPHRD_ETHER)
686                 IPCB(skb)->flags = 0;
687
688         if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
689                 gre_hlen = 0;
690                 tiph = (struct iphdr *)skb->data;
691         } else {
692                 gre_hlen = tunnel->hlen;
693                 tiph = &tunnel->parms.iph;
694         }
695
696         if ((dst = tiph->daddr) == 0) {
697                 /* NBMA tunnel */
698
699                 if (skb_dst(skb) == NULL) {
700                         stats->tx_fifo_errors++;
701                         goto tx_error;
702                 }
703
704                 if (skb->protocol == htons(ETH_P_IP)) {
705                         rt = skb_rtable(skb);
706                         if ((dst = rt->rt_gateway) == 0)
707                                 goto tx_error_icmp;
708                 }
709 #ifdef CONFIG_IPV6
710                 else if (skb->protocol == htons(ETH_P_IPV6)) {
711                         struct in6_addr *addr6;
712                         int addr_type;
713                         struct neighbour *neigh = skb_dst(skb)->neighbour;
714
715                         if (neigh == NULL)
716                                 goto tx_error;
717
718                         addr6 = (struct in6_addr *)&neigh->primary_key;
719                         addr_type = ipv6_addr_type(addr6);
720
721                         if (addr_type == IPV6_ADDR_ANY) {
722                                 addr6 = &ipv6_hdr(skb)->daddr;
723                                 addr_type = ipv6_addr_type(addr6);
724                         }
725
726                         if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
727                                 goto tx_error_icmp;
728
729                         dst = addr6->s6_addr32[3];
730                 }
731 #endif
732                 else
733                         goto tx_error;
734         }
735
736         tos = tiph->tos;
737         if (tos == 1) {
738                 tos = 0;
739                 if (skb->protocol == htons(ETH_P_IP))
740                         tos = old_iph->tos;
741         }
742
743         {
744                 struct flowi fl = { .oif = tunnel->parms.link,
745                                     .nl_u = { .ip4_u =
746                                               { .daddr = dst,
747                                                 .saddr = tiph->saddr,
748                                                 .tos = RT_TOS(tos) } },
749                                     .proto = IPPROTO_GRE };
750                 if (ip_route_output_key(dev_net(dev), &rt, &fl)) {
751                         stats->tx_carrier_errors++;
752                         goto tx_error;
753                 }
754         }
755         tdev = rt->u.dst.dev;
756
757         if (tdev == dev) {
758                 ip_rt_put(rt);
759                 stats->collisions++;
760                 goto tx_error;
761         }
762
763         df = tiph->frag_off;
764         if (df)
765                 mtu = dst_mtu(&rt->u.dst) - dev->hard_header_len - tunnel->hlen;
766         else
767                 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
768
769         if (skb_dst(skb))
770                 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
771
772         if (skb->protocol == htons(ETH_P_IP)) {
773                 df |= (old_iph->frag_off&htons(IP_DF));
774
775                 if ((old_iph->frag_off&htons(IP_DF)) &&
776                     mtu < ntohs(old_iph->tot_len)) {
777                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
778                         ip_rt_put(rt);
779                         goto tx_error;
780                 }
781         }
782 #ifdef CONFIG_IPV6
783         else if (skb->protocol == htons(ETH_P_IPV6)) {
784                 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
785
786                 if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
787                         if ((tunnel->parms.iph.daddr &&
788                              !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
789                             rt6->rt6i_dst.plen == 128) {
790                                 rt6->rt6i_flags |= RTF_MODIFIED;
791                                 skb_dst(skb)->metrics[RTAX_MTU-1] = mtu;
792                         }
793                 }
794
795                 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
796                         icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
797                         ip_rt_put(rt);
798                         goto tx_error;
799                 }
800         }
801 #endif
802
803         if (tunnel->err_count > 0) {
804                 if (time_before(jiffies,
805                                 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
806                         tunnel->err_count--;
807
808                         dst_link_failure(skb);
809                 } else
810                         tunnel->err_count = 0;
811         }
812
813         max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->u.dst.header_len;
814
815         if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
816             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
817                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
818                 if (max_headroom > dev->needed_headroom)
819                         dev->needed_headroom = max_headroom;
820                 if (!new_skb) {
821                         ip_rt_put(rt);
822                         txq->tx_dropped++;
823                         dev_kfree_skb(skb);
824                         return NETDEV_TX_OK;
825                 }
826                 if (skb->sk)
827                         skb_set_owner_w(new_skb, skb->sk);
828                 dev_kfree_skb(skb);
829                 skb = new_skb;
830                 old_iph = ip_hdr(skb);
831         }
832
833         skb_reset_transport_header(skb);
834         skb_push(skb, gre_hlen);
835         skb_reset_network_header(skb);
836         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
837         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
838                               IPSKB_REROUTED);
839         skb_dst_drop(skb);
840         skb_dst_set(skb, &rt->u.dst);
841
842         /*
843          *      Push down and install the IPIP header.
844          */
845
846         iph                     =       ip_hdr(skb);
847         iph->version            =       4;
848         iph->ihl                =       sizeof(struct iphdr) >> 2;
849         iph->frag_off           =       df;
850         iph->protocol           =       IPPROTO_GRE;
851         iph->tos                =       ipgre_ecn_encapsulate(tos, old_iph, skb);
852         iph->daddr              =       rt->rt_dst;
853         iph->saddr              =       rt->rt_src;
854
855         if ((iph->ttl = tiph->ttl) == 0) {
856                 if (skb->protocol == htons(ETH_P_IP))
857                         iph->ttl = old_iph->ttl;
858 #ifdef CONFIG_IPV6
859                 else if (skb->protocol == htons(ETH_P_IPV6))
860                         iph->ttl = ((struct ipv6hdr *)old_iph)->hop_limit;
861 #endif
862                 else
863                         iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
864         }
865
866         ((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
867         ((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
868                                    htons(ETH_P_TEB) : skb->protocol;
869
870         if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
871                 __be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
872
873                 if (tunnel->parms.o_flags&GRE_SEQ) {
874                         ++tunnel->o_seqno;
875                         *ptr = htonl(tunnel->o_seqno);
876                         ptr--;
877                 }
878                 if (tunnel->parms.o_flags&GRE_KEY) {
879                         *ptr = tunnel->parms.o_key;
880                         ptr--;
881                 }
882                 if (tunnel->parms.o_flags&GRE_CSUM) {
883                         *ptr = 0;
884                         *(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
885                 }
886         }
887
888         nf_reset(skb);
889
890         IPTUNNEL_XMIT();
891         return NETDEV_TX_OK;
892
893 tx_error_icmp:
894         dst_link_failure(skb);
895
896 tx_error:
897         stats->tx_errors++;
898         dev_kfree_skb(skb);
899         return NETDEV_TX_OK;
900 }
901
902 static int ipgre_tunnel_bind_dev(struct net_device *dev)
903 {
904         struct net_device *tdev = NULL;
905         struct ip_tunnel *tunnel;
906         struct iphdr *iph;
907         int hlen = LL_MAX_HEADER;
908         int mtu = ETH_DATA_LEN;
909         int addend = sizeof(struct iphdr) + 4;
910
911         tunnel = netdev_priv(dev);
912         iph = &tunnel->parms.iph;
913
914         /* Guess output device to choose reasonable mtu and needed_headroom */
915
916         if (iph->daddr) {
917                 struct flowi fl = { .oif = tunnel->parms.link,
918                                     .nl_u = { .ip4_u =
919                                               { .daddr = iph->daddr,
920                                                 .saddr = iph->saddr,
921                                                 .tos = RT_TOS(iph->tos) } },
922                                     .proto = IPPROTO_GRE };
923                 struct rtable *rt;
924                 if (!ip_route_output_key(dev_net(dev), &rt, &fl)) {
925                         tdev = rt->u.dst.dev;
926                         ip_rt_put(rt);
927                 }
928
929                 if (dev->type != ARPHRD_ETHER)
930                         dev->flags |= IFF_POINTOPOINT;
931         }
932
933         if (!tdev && tunnel->parms.link)
934                 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
935
936         if (tdev) {
937                 hlen = tdev->hard_header_len + tdev->needed_headroom;
938                 mtu = tdev->mtu;
939         }
940         dev->iflink = tunnel->parms.link;
941
942         /* Precalculate GRE options length */
943         if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
944                 if (tunnel->parms.o_flags&GRE_CSUM)
945                         addend += 4;
946                 if (tunnel->parms.o_flags&GRE_KEY)
947                         addend += 4;
948                 if (tunnel->parms.o_flags&GRE_SEQ)
949                         addend += 4;
950         }
951         dev->needed_headroom = addend + hlen;
952         mtu -= dev->hard_header_len + addend;
953
954         if (mtu < 68)
955                 mtu = 68;
956
957         tunnel->hlen = addend;
958
959         return mtu;
960 }
961
962 static int
963 ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
964 {
965         int err = 0;
966         struct ip_tunnel_parm p;
967         struct ip_tunnel *t;
968         struct net *net = dev_net(dev);
969         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
970
971         switch (cmd) {
972         case SIOCGETTUNNEL:
973                 t = NULL;
974                 if (dev == ign->fb_tunnel_dev) {
975                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
976                                 err = -EFAULT;
977                                 break;
978                         }
979                         t = ipgre_tunnel_locate(net, &p, 0);
980                 }
981                 if (t == NULL)
982                         t = netdev_priv(dev);
983                 memcpy(&p, &t->parms, sizeof(p));
984                 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
985                         err = -EFAULT;
986                 break;
987
988         case SIOCADDTUNNEL:
989         case SIOCCHGTUNNEL:
990                 err = -EPERM;
991                 if (!capable(CAP_NET_ADMIN))
992                         goto done;
993
994                 err = -EFAULT;
995                 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
996                         goto done;
997
998                 err = -EINVAL;
999                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
1000                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
1001                     ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
1002                         goto done;
1003                 if (p.iph.ttl)
1004                         p.iph.frag_off |= htons(IP_DF);
1005
1006                 if (!(p.i_flags&GRE_KEY))
1007                         p.i_key = 0;
1008                 if (!(p.o_flags&GRE_KEY))
1009                         p.o_key = 0;
1010
1011                 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1012
1013                 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1014                         if (t != NULL) {
1015                                 if (t->dev != dev) {
1016                                         err = -EEXIST;
1017                                         break;
1018                                 }
1019                         } else {
1020                                 unsigned nflags = 0;
1021
1022                                 t = netdev_priv(dev);
1023
1024                                 if (ipv4_is_multicast(p.iph.daddr))
1025                                         nflags = IFF_BROADCAST;
1026                                 else if (p.iph.daddr)
1027                                         nflags = IFF_POINTOPOINT;
1028
1029                                 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
1030                                         err = -EINVAL;
1031                                         break;
1032                                 }
1033                                 ipgre_tunnel_unlink(ign, t);
1034                                 t->parms.iph.saddr = p.iph.saddr;
1035                                 t->parms.iph.daddr = p.iph.daddr;
1036                                 t->parms.i_key = p.i_key;
1037                                 t->parms.o_key = p.o_key;
1038                                 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1039                                 memcpy(dev->broadcast, &p.iph.daddr, 4);
1040                                 ipgre_tunnel_link(ign, t);
1041                                 netdev_state_change(dev);
1042                         }
1043                 }
1044
1045                 if (t) {
1046                         err = 0;
1047                         if (cmd == SIOCCHGTUNNEL) {
1048                                 t->parms.iph.ttl = p.iph.ttl;
1049                                 t->parms.iph.tos = p.iph.tos;
1050                                 t->parms.iph.frag_off = p.iph.frag_off;
1051                                 if (t->parms.link != p.link) {
1052                                         t->parms.link = p.link;
1053                                         dev->mtu = ipgre_tunnel_bind_dev(dev);
1054                                         netdev_state_change(dev);
1055                                 }
1056                         }
1057                         if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1058                                 err = -EFAULT;
1059                 } else
1060                         err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1061                 break;
1062
1063         case SIOCDELTUNNEL:
1064                 err = -EPERM;
1065                 if (!capable(CAP_NET_ADMIN))
1066                         goto done;
1067
1068                 if (dev == ign->fb_tunnel_dev) {
1069                         err = -EFAULT;
1070                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1071                                 goto done;
1072                         err = -ENOENT;
1073                         if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
1074                                 goto done;
1075                         err = -EPERM;
1076                         if (t == netdev_priv(ign->fb_tunnel_dev))
1077                                 goto done;
1078                         dev = t->dev;
1079                 }
1080                 unregister_netdevice(dev);
1081                 err = 0;
1082                 break;
1083
1084         default:
1085                 err = -EINVAL;
1086         }
1087
1088 done:
1089         return err;
1090 }
1091
1092 static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1093 {
1094         struct ip_tunnel *tunnel = netdev_priv(dev);
1095         if (new_mtu < 68 ||
1096             new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
1097                 return -EINVAL;
1098         dev->mtu = new_mtu;
1099         return 0;
1100 }
1101
1102 /* Nice toy. Unfortunately, useless in real life :-)
1103    It allows to construct virtual multiprotocol broadcast "LAN"
1104    over the Internet, provided multicast routing is tuned.
1105
1106
1107    I have no idea was this bicycle invented before me,
1108    so that I had to set ARPHRD_IPGRE to a random value.
1109    I have an impression, that Cisco could make something similar,
1110    but this feature is apparently missing in IOS<=11.2(8).
1111
1112    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1113    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1114
1115    ping -t 255 224.66.66.66
1116
1117    If nobody answers, mbone does not work.
1118
1119    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1120    ip addr add 10.66.66.<somewhat>/24 dev Universe
1121    ifconfig Universe up
1122    ifconfig Universe add fe80::<Your_real_addr>/10
1123    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1124    ftp 10.66.66.66
1125    ...
1126    ftp fec0:6666:6666::193.233.7.65
1127    ...
1128
1129  */
1130
1131 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1132                         unsigned short type,
1133                         const void *daddr, const void *saddr, unsigned len)
1134 {
1135         struct ip_tunnel *t = netdev_priv(dev);
1136         struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1137         __be16 *p = (__be16*)(iph+1);
1138
1139         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1140         p[0]            = t->parms.o_flags;
1141         p[1]            = htons(type);
1142
1143         /*
1144          *      Set the source hardware address.
1145          */
1146
1147         if (saddr)
1148                 memcpy(&iph->saddr, saddr, 4);
1149         if (daddr)
1150                 memcpy(&iph->daddr, daddr, 4);
1151         if (iph->daddr)
1152                 return t->hlen;
1153
1154         return -t->hlen;
1155 }
1156
1157 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1158 {
1159         struct iphdr *iph = (struct iphdr *) skb_mac_header(skb);
1160         memcpy(haddr, &iph->saddr, 4);
1161         return 4;
1162 }
1163
1164 static const struct header_ops ipgre_header_ops = {
1165         .create = ipgre_header,
1166         .parse  = ipgre_header_parse,
1167 };
1168
1169 #ifdef CONFIG_NET_IPGRE_BROADCAST
1170 static int ipgre_open(struct net_device *dev)
1171 {
1172         struct ip_tunnel *t = netdev_priv(dev);
1173
1174         if (ipv4_is_multicast(t->parms.iph.daddr)) {
1175                 struct flowi fl = { .oif = t->parms.link,
1176                                     .nl_u = { .ip4_u =
1177                                               { .daddr = t->parms.iph.daddr,
1178                                                 .saddr = t->parms.iph.saddr,
1179                                                 .tos = RT_TOS(t->parms.iph.tos) } },
1180                                     .proto = IPPROTO_GRE };
1181                 struct rtable *rt;
1182                 if (ip_route_output_key(dev_net(dev), &rt, &fl))
1183                         return -EADDRNOTAVAIL;
1184                 dev = rt->u.dst.dev;
1185                 ip_rt_put(rt);
1186                 if (__in_dev_get_rtnl(dev) == NULL)
1187                         return -EADDRNOTAVAIL;
1188                 t->mlink = dev->ifindex;
1189                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
1190         }
1191         return 0;
1192 }
1193
1194 static int ipgre_close(struct net_device *dev)
1195 {
1196         struct ip_tunnel *t = netdev_priv(dev);
1197
1198         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
1199                 struct in_device *in_dev;
1200                 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
1201                 if (in_dev) {
1202                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1203                         in_dev_put(in_dev);
1204                 }
1205         }
1206         return 0;
1207 }
1208
1209 #endif
1210
1211 static const struct net_device_ops ipgre_netdev_ops = {
1212         .ndo_init               = ipgre_tunnel_init,
1213         .ndo_uninit             = ipgre_tunnel_uninit,
1214 #ifdef CONFIG_NET_IPGRE_BROADCAST
1215         .ndo_open               = ipgre_open,
1216         .ndo_stop               = ipgre_close,
1217 #endif
1218         .ndo_start_xmit         = ipgre_tunnel_xmit,
1219         .ndo_do_ioctl           = ipgre_tunnel_ioctl,
1220         .ndo_change_mtu         = ipgre_tunnel_change_mtu,
1221 };
1222
1223 static void ipgre_tunnel_setup(struct net_device *dev)
1224 {
1225         dev->netdev_ops         = &ipgre_netdev_ops;
1226         dev->destructor         = free_netdev;
1227
1228         dev->type               = ARPHRD_IPGRE;
1229         dev->needed_headroom    = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1230         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
1231         dev->flags              = IFF_NOARP;
1232         dev->iflink             = 0;
1233         dev->addr_len           = 4;
1234         dev->features           |= NETIF_F_NETNS_LOCAL;
1235         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
1236 }
1237
1238 static int ipgre_tunnel_init(struct net_device *dev)
1239 {
1240         struct ip_tunnel *tunnel;
1241         struct iphdr *iph;
1242
1243         tunnel = netdev_priv(dev);
1244         iph = &tunnel->parms.iph;
1245
1246         tunnel->dev = dev;
1247         strcpy(tunnel->parms.name, dev->name);
1248
1249         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1250         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1251
1252         if (iph->daddr) {
1253 #ifdef CONFIG_NET_IPGRE_BROADCAST
1254                 if (ipv4_is_multicast(iph->daddr)) {
1255                         if (!iph->saddr)
1256                                 return -EINVAL;
1257                         dev->flags = IFF_BROADCAST;
1258                         dev->header_ops = &ipgre_header_ops;
1259                 }
1260 #endif
1261         } else
1262                 dev->header_ops = &ipgre_header_ops;
1263
1264         return 0;
1265 }
1266
1267 static void ipgre_fb_tunnel_init(struct net_device *dev)
1268 {
1269         struct ip_tunnel *tunnel = netdev_priv(dev);
1270         struct iphdr *iph = &tunnel->parms.iph;
1271         struct ipgre_net *ign = net_generic(dev_net(dev), ipgre_net_id);
1272
1273         tunnel->dev = dev;
1274         strcpy(tunnel->parms.name, dev->name);
1275
1276         iph->version            = 4;
1277         iph->protocol           = IPPROTO_GRE;
1278         iph->ihl                = 5;
1279         tunnel->hlen            = sizeof(struct iphdr) + 4;
1280
1281         dev_hold(dev);
1282         ign->tunnels_wc[0]      = tunnel;
1283 }
1284
1285
1286 static const struct net_protocol ipgre_protocol = {
1287         .handler        =       ipgre_rcv,
1288         .err_handler    =       ipgre_err,
1289         .netns_ok       =       1,
1290 };
1291
1292 static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
1293 {
1294         int prio;
1295
1296         for (prio = 0; prio < 4; prio++) {
1297                 int h;
1298                 for (h = 0; h < HASH_SIZE; h++) {
1299                         struct ip_tunnel *t = ign->tunnels[prio][h];
1300
1301                         while (t != NULL) {
1302                                 unregister_netdevice_queue(t->dev, head);
1303                                 t = t->next;
1304                         }
1305                 }
1306         }
1307 }
1308
1309 static int __net_init ipgre_init_net(struct net *net)
1310 {
1311         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1312         int err;
1313
1314         ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1315                                            ipgre_tunnel_setup);
1316         if (!ign->fb_tunnel_dev) {
1317                 err = -ENOMEM;
1318                 goto err_alloc_dev;
1319         }
1320         dev_net_set(ign->fb_tunnel_dev, net);
1321
1322         ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
1323         ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
1324
1325         if ((err = register_netdev(ign->fb_tunnel_dev)))
1326                 goto err_reg_dev;
1327
1328         return 0;
1329
1330 err_reg_dev:
1331         free_netdev(ign->fb_tunnel_dev);
1332 err_alloc_dev:
1333         return err;
1334 }
1335
1336 static void __net_exit ipgre_exit_net(struct net *net)
1337 {
1338         struct ipgre_net *ign;
1339         LIST_HEAD(list);
1340
1341         ign = net_generic(net, ipgre_net_id);
1342         rtnl_lock();
1343         ipgre_destroy_tunnels(ign, &list);
1344         unregister_netdevice_many(&list);
1345         rtnl_unlock();
1346 }
1347
1348 static struct pernet_operations ipgre_net_ops = {
1349         .init = ipgre_init_net,
1350         .exit = ipgre_exit_net,
1351         .id   = &ipgre_net_id,
1352         .size = sizeof(struct ipgre_net),
1353 };
1354
1355 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
1356 {
1357         __be16 flags;
1358
1359         if (!data)
1360                 return 0;
1361
1362         flags = 0;
1363         if (data[IFLA_GRE_IFLAGS])
1364                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1365         if (data[IFLA_GRE_OFLAGS])
1366                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1367         if (flags & (GRE_VERSION|GRE_ROUTING))
1368                 return -EINVAL;
1369
1370         return 0;
1371 }
1372
1373 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1374 {
1375         __be32 daddr;
1376
1377         if (tb[IFLA_ADDRESS]) {
1378                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1379                         return -EINVAL;
1380                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1381                         return -EADDRNOTAVAIL;
1382         }
1383
1384         if (!data)
1385                 goto out;
1386
1387         if (data[IFLA_GRE_REMOTE]) {
1388                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1389                 if (!daddr)
1390                         return -EINVAL;
1391         }
1392
1393 out:
1394         return ipgre_tunnel_validate(tb, data);
1395 }
1396
1397 static void ipgre_netlink_parms(struct nlattr *data[],
1398                                 struct ip_tunnel_parm *parms)
1399 {
1400         memset(parms, 0, sizeof(*parms));
1401
1402         parms->iph.protocol = IPPROTO_GRE;
1403
1404         if (!data)
1405                 return;
1406
1407         if (data[IFLA_GRE_LINK])
1408                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1409
1410         if (data[IFLA_GRE_IFLAGS])
1411                 parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);
1412
1413         if (data[IFLA_GRE_OFLAGS])
1414                 parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);
1415
1416         if (data[IFLA_GRE_IKEY])
1417                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1418
1419         if (data[IFLA_GRE_OKEY])
1420                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1421
1422         if (data[IFLA_GRE_LOCAL])
1423                 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
1424
1425         if (data[IFLA_GRE_REMOTE])
1426                 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
1427
1428         if (data[IFLA_GRE_TTL])
1429                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1430
1431         if (data[IFLA_GRE_TOS])
1432                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1433
1434         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
1435                 parms->iph.frag_off = htons(IP_DF);
1436 }
1437
1438 static int ipgre_tap_init(struct net_device *dev)
1439 {
1440         struct ip_tunnel *tunnel;
1441
1442         tunnel = netdev_priv(dev);
1443
1444         tunnel->dev = dev;
1445         strcpy(tunnel->parms.name, dev->name);
1446
1447         ipgre_tunnel_bind_dev(dev);
1448
1449         return 0;
1450 }
1451
1452 static const struct net_device_ops ipgre_tap_netdev_ops = {
1453         .ndo_init               = ipgre_tap_init,
1454         .ndo_uninit             = ipgre_tunnel_uninit,
1455         .ndo_start_xmit         = ipgre_tunnel_xmit,
1456         .ndo_set_mac_address    = eth_mac_addr,
1457         .ndo_validate_addr      = eth_validate_addr,
1458         .ndo_change_mtu         = ipgre_tunnel_change_mtu,
1459 };
1460
1461 static void ipgre_tap_setup(struct net_device *dev)
1462 {
1463
1464         ether_setup(dev);
1465
1466         dev->netdev_ops         = &ipgre_tap_netdev_ops;
1467         dev->destructor         = free_netdev;
1468
1469         dev->iflink             = 0;
1470         dev->features           |= NETIF_F_NETNS_LOCAL;
1471 }
1472
1473 static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
1474                          struct nlattr *data[])
1475 {
1476         struct ip_tunnel *nt;
1477         struct net *net = dev_net(dev);
1478         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1479         int mtu;
1480         int err;
1481
1482         nt = netdev_priv(dev);
1483         ipgre_netlink_parms(data, &nt->parms);
1484
1485         if (ipgre_tunnel_find(net, &nt->parms, dev->type))
1486                 return -EEXIST;
1487
1488         if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
1489                 random_ether_addr(dev->dev_addr);
1490
1491         mtu = ipgre_tunnel_bind_dev(dev);
1492         if (!tb[IFLA_MTU])
1493                 dev->mtu = mtu;
1494
1495         err = register_netdevice(dev);
1496         if (err)
1497                 goto out;
1498
1499         dev_hold(dev);
1500         ipgre_tunnel_link(ign, nt);
1501
1502 out:
1503         return err;
1504 }
1505
1506 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1507                             struct nlattr *data[])
1508 {
1509         struct ip_tunnel *t, *nt;
1510         struct net *net = dev_net(dev);
1511         struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1512         struct ip_tunnel_parm p;
1513         int mtu;
1514
1515         if (dev == ign->fb_tunnel_dev)
1516                 return -EINVAL;
1517
1518         nt = netdev_priv(dev);
1519         ipgre_netlink_parms(data, &p);
1520
1521         t = ipgre_tunnel_locate(net, &p, 0);
1522
1523         if (t) {
1524                 if (t->dev != dev)
1525                         return -EEXIST;
1526         } else {
1527                 t = nt;
1528
1529                 if (dev->type != ARPHRD_ETHER) {
1530                         unsigned nflags = 0;
1531
1532                         if (ipv4_is_multicast(p.iph.daddr))
1533                                 nflags = IFF_BROADCAST;
1534                         else if (p.iph.daddr)
1535                                 nflags = IFF_POINTOPOINT;
1536
1537                         if ((dev->flags ^ nflags) &
1538                             (IFF_POINTOPOINT | IFF_BROADCAST))
1539                                 return -EINVAL;
1540                 }
1541
1542                 ipgre_tunnel_unlink(ign, t);
1543                 t->parms.iph.saddr = p.iph.saddr;
1544                 t->parms.iph.daddr = p.iph.daddr;
1545                 t->parms.i_key = p.i_key;
1546                 if (dev->type != ARPHRD_ETHER) {
1547                         memcpy(dev->dev_addr, &p.iph.saddr, 4);
1548                         memcpy(dev->broadcast, &p.iph.daddr, 4);
1549                 }
1550                 ipgre_tunnel_link(ign, t);
1551                 netdev_state_change(dev);
1552         }
1553
1554         t->parms.o_key = p.o_key;
1555         t->parms.iph.ttl = p.iph.ttl;
1556         t->parms.iph.tos = p.iph.tos;
1557         t->parms.iph.frag_off = p.iph.frag_off;
1558
1559         if (t->parms.link != p.link) {
1560                 t->parms.link = p.link;
1561                 mtu = ipgre_tunnel_bind_dev(dev);
1562                 if (!tb[IFLA_MTU])
1563                         dev->mtu = mtu;
1564                 netdev_state_change(dev);
1565         }
1566
1567         return 0;
1568 }
1569
1570 static size_t ipgre_get_size(const struct net_device *dev)
1571 {
1572         return
1573                 /* IFLA_GRE_LINK */
1574                 nla_total_size(4) +
1575                 /* IFLA_GRE_IFLAGS */
1576                 nla_total_size(2) +
1577                 /* IFLA_GRE_OFLAGS */
1578                 nla_total_size(2) +
1579                 /* IFLA_GRE_IKEY */
1580                 nla_total_size(4) +
1581                 /* IFLA_GRE_OKEY */
1582                 nla_total_size(4) +
1583                 /* IFLA_GRE_LOCAL */
1584                 nla_total_size(4) +
1585                 /* IFLA_GRE_REMOTE */
1586                 nla_total_size(4) +
1587                 /* IFLA_GRE_TTL */
1588                 nla_total_size(1) +
1589                 /* IFLA_GRE_TOS */
1590                 nla_total_size(1) +
1591                 /* IFLA_GRE_PMTUDISC */
1592                 nla_total_size(1) +
1593                 0;
1594 }
1595
1596 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1597 {
1598         struct ip_tunnel *t = netdev_priv(dev);
1599         struct ip_tunnel_parm *p = &t->parms;
1600
1601         NLA_PUT_U32(skb, IFLA_GRE_LINK, p->link);
1602         NLA_PUT_BE16(skb, IFLA_GRE_IFLAGS, p->i_flags);
1603         NLA_PUT_BE16(skb, IFLA_GRE_OFLAGS, p->o_flags);
1604         NLA_PUT_BE32(skb, IFLA_GRE_IKEY, p->i_key);
1605         NLA_PUT_BE32(skb, IFLA_GRE_OKEY, p->o_key);
1606         NLA_PUT_BE32(skb, IFLA_GRE_LOCAL, p->iph.saddr);
1607         NLA_PUT_BE32(skb, IFLA_GRE_REMOTE, p->iph.daddr);
1608         NLA_PUT_U8(skb, IFLA_GRE_TTL, p->iph.ttl);
1609         NLA_PUT_U8(skb, IFLA_GRE_TOS, p->iph.tos);
1610         NLA_PUT_U8(skb, IFLA_GRE_PMTUDISC, !!(p->iph.frag_off & htons(IP_DF)));
1611
1612         return 0;
1613
1614 nla_put_failure:
1615         return -EMSGSIZE;
1616 }
1617
1618 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1619         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
1620         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
1621         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
1622         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
1623         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
1624         [IFLA_GRE_LOCAL]        = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1625         [IFLA_GRE_REMOTE]       = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
1626         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
1627         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
1628         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
1629 };
1630
1631 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1632         .kind           = "gre",
1633         .maxtype        = IFLA_GRE_MAX,
1634         .policy         = ipgre_policy,
1635         .priv_size      = sizeof(struct ip_tunnel),
1636         .setup          = ipgre_tunnel_setup,
1637         .validate       = ipgre_tunnel_validate,
1638         .newlink        = ipgre_newlink,
1639         .changelink     = ipgre_changelink,
1640         .get_size       = ipgre_get_size,
1641         .fill_info      = ipgre_fill_info,
1642 };
1643
1644 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1645         .kind           = "gretap",
1646         .maxtype        = IFLA_GRE_MAX,
1647         .policy         = ipgre_policy,
1648         .priv_size      = sizeof(struct ip_tunnel),
1649         .setup          = ipgre_tap_setup,
1650         .validate       = ipgre_tap_validate,
1651         .newlink        = ipgre_newlink,
1652         .changelink     = ipgre_changelink,
1653         .get_size       = ipgre_get_size,
1654         .fill_info      = ipgre_fill_info,
1655 };
1656
1657 /*
1658  *      And now the modules code and kernel interface.
1659  */
1660
1661 static int __init ipgre_init(void)
1662 {
1663         int err;
1664
1665         printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1666
1667         err = register_pernet_device(&ipgre_net_ops);
1668         if (err < 0)
1669                 return err;
1670
1671         err = inet_add_protocol(&ipgre_protocol, IPPROTO_GRE);
1672         if (err < 0) {
1673                 printk(KERN_INFO "ipgre init: can't add protocol\n");
1674                 goto add_proto_failed;
1675         }
1676
1677         err = rtnl_link_register(&ipgre_link_ops);
1678         if (err < 0)
1679                 goto rtnl_link_failed;
1680
1681         err = rtnl_link_register(&ipgre_tap_ops);
1682         if (err < 0)
1683                 goto tap_ops_failed;
1684
1685 out:
1686         return err;
1687
1688 tap_ops_failed:
1689         rtnl_link_unregister(&ipgre_link_ops);
1690 rtnl_link_failed:
1691         inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1692 add_proto_failed:
1693         unregister_pernet_device(&ipgre_net_ops);
1694         goto out;
1695 }
1696
1697 static void __exit ipgre_fini(void)
1698 {
1699         rtnl_link_unregister(&ipgre_tap_ops);
1700         rtnl_link_unregister(&ipgre_link_ops);
1701         if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1702                 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1703         unregister_pernet_device(&ipgre_net_ops);
1704 }
1705
1706 module_init(ipgre_init);
1707 module_exit(ipgre_fini);
1708 MODULE_LICENSE("GPL");
1709 MODULE_ALIAS_RTNL_LINK("gre");
1710 MODULE_ALIAS_RTNL_LINK("gretap");