projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[IPIP]: Introduce empty ipip_net structure and net init/exit ops.
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / ipv4 / ipip.c
1 /*
2 * Linux NET3: IP/IP protocol decoder.
3 *
4 * Version: $Id: ipip.c,v 1.50 2001/10/02 02:22:36 davem Exp $
5 *
6 * Authors:
7 * Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
8 *
9 * Fixes:
10 * Alan Cox : Merged and made usable non modular (its so tiny its silly as
11 * a module taking up 2 pages).
12 * Alan Cox : Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph)
13 * to keep ip_forward happy.
14 * Alan Cox : More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8).
15 * Kai Schulte : Fixed #defines for IP_FIREWALL->FIREWALL
16 * David Woodhouse : Perform some basic ICMP handling.
17 * IPIP Routing without decapsulation.
18 * Carlos Picoto : GRE over IP support
19 * Alexey Kuznetsov: Reworked. Really, now it is truncated version of ipv4/ip_gre.c.
20 * I do not want to merge them together.
21 *
22 * This program is free software; you can redistribute it and/or
23 * modify it under the terms of the GNU General Public License
24 * as published by the Free Software Foundation; either version
25 * 2 of the License, or (at your option) any later version.
26 *
27 */
28
29 /* tunnel.c: an IP tunnel driver
30
31 The purpose of this driver is to provide an IP tunnel through
32 which you can tunnel network traffic transparently across subnets.
33
34 This was written by looking at Nick Holloway's dummy driver
35 Thanks for the great code!
36
37 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
38
39 Minor tweaks:
40 Cleaned up the code a little and added some pre-1.3.0 tweaks.
41 dev->hard_header/hard_header_len changed to use no headers.
42 Comments/bracketing tweaked.
43 Made the tunnels use dev->name not tunnel: when error reporting.
44 Added tx_dropped stat
45
46 -Alan Cox (Alan.Cox@linux.org) 21 March 95
47
48 Reworked:
49 Changed to tunnel to destination gateway in addition to the
50 tunnel's pointopoint address
51 Almost completely rewritten
52 Note: There is currently no firewall or ICMP handling done.
53
54 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96
55
56 */
57
58 /* Things I wish I had known when writing the tunnel driver:
59
60 When the tunnel_xmit() function is called, the skb contains the
61 packet to be sent (plus a great deal of extra info), and dev
62 contains the tunnel device that _we_ are.
63
64 When we are passed a packet, we are expected to fill in the
65 source address with our source IP address.
66
67 What is the proper way to allocate, copy and free a buffer?
68 After you allocate it, it is a "0 length" chunk of memory
69 starting at zero. If you want to add headers to the buffer
70 later, you'll have to call "skb_reserve(skb, amount)" with
71 the amount of memory you want reserved. Then, you call
72 "skb_put(skb, amount)" with the amount of space you want in
73 the buffer. skb_put() returns a pointer to the top (#0) of
74 that buffer. skb->len is set to the amount of space you have
75 "allocated" with skb_put(). You can then write up to skb->len
76 bytes to that buffer. If you need more, you can call skb_put()
77 again with the additional amount of space you need. You can
78 find out how much more space you can allocate by calling
79 "skb_tailroom(skb)".
80 Now, to add header space, call "skb_push(skb, header_len)".
81 This creates space at the beginning of the buffer and returns
82 a pointer to this new space. If later you need to strip a
83 header from a buffer, call "skb_pull(skb, header_len)".
84 skb_headroom() will return how much space is left at the top
85 of the buffer (before the main data). Remember, this headroom
86 space must be reserved before the skb_put() function is called.
87 */
88
89 /*
90 This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
91
92 For comments look at net/ipv4/ip_gre.c --ANK
93 */
94
95
96 #include <linux/capability.h>
97 #include <linux/module.h>
98 #include <linux/types.h>
99 #include <linux/kernel.h>
100 #include <asm/uaccess.h>
101 #include <linux/skbuff.h>
102 #include <linux/netdevice.h>
103 #include <linux/in.h>
104 #include <linux/tcp.h>
105 #include <linux/udp.h>
106 #include <linux/if_arp.h>
107 #include <linux/mroute.h>
108 #include <linux/init.h>
109 #include <linux/netfilter_ipv4.h>
110 #include <linux/if_ether.h>
111
112 #include <net/sock.h>
113 #include <net/ip.h>
114 #include <net/icmp.h>
115 #include <net/ipip.h>
116 #include <net/inet_ecn.h>
117 #include <net/xfrm.h>
118 #include <net/net_namespace.h>
119 #include <net/netns/generic.h>
120
121 #define HASH_SIZE 16
122 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
123
124 static int ipip_net_id;
125 struct ipip_net {
126 };
127
128 static int ipip_fb_tunnel_init(struct net_device *dev);
129 static int ipip_tunnel_init(struct net_device *dev);
130 static void ipip_tunnel_setup(struct net_device *dev);
131
132 static struct net_device *ipip_fb_tunnel_dev;
133
134 static struct ip_tunnel *tunnels_r_l[HASH_SIZE];
135 static struct ip_tunnel *tunnels_r[HASH_SIZE];
136 static struct ip_tunnel *tunnels_l[HASH_SIZE];
137 static struct ip_tunnel *tunnels_wc[1];
138 static struct ip_tunnel **tunnels[4] = { tunnels_wc, tunnels_l, tunnels_r, tunnels_r_l };
139
140 static DEFINE_RWLOCK(ipip_lock);
141
142 static struct ip_tunnel * ipip_tunnel_lookup(__be32 remote, __be32 local)
143 {
144 unsigned h0 = HASH(remote);
145 unsigned h1 = HASH(local);
146 struct ip_tunnel *t;
147
148 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
149 if (local == t->parms.iph.saddr &&
150 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
151 return t;
152 }
153 for (t = tunnels_r[h0]; t; t = t->next) {
154 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
155 return t;
156 }
157 for (t = tunnels_l[h1]; t; t = t->next) {
158 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
159 return t;
160 }
161 if ((t = tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
162 return t;
163 return NULL;
164 }
165
166 static struct ip_tunnel **__ipip_bucket(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 &tunnels[prio][h];
182 }
183
184 static inline struct ip_tunnel **ipip_bucket(struct ip_tunnel *t)
185 {
186 return __ipip_bucket(&t->parms);
187 }
188
189 static void ipip_tunnel_unlink(struct ip_tunnel *t)
190 {
191 struct ip_tunnel **tp;
192
193 for (tp = ipip_bucket(t); *tp; tp = &(*tp)->next) {
194 if (t == *tp) {
195 write_lock_bh(&ipip_lock);
196 *tp = t->next;
197 write_unlock_bh(&ipip_lock);
198 break;
199 }
200 }
201 }
202
203 static void ipip_tunnel_link(struct ip_tunnel *t)
204 {
205 struct ip_tunnel **tp = ipip_bucket(t);
206
207 t->next = *tp;
208 write_lock_bh(&ipip_lock);
209 *tp = t;
210 write_unlock_bh(&ipip_lock);
211 }
212
213 static struct ip_tunnel * ipip_tunnel_locate(struct ip_tunnel_parm *parms, int create)
214 {
215 __be32 remote = parms->iph.daddr;
216 __be32 local = parms->iph.saddr;
217 struct ip_tunnel *t, **tp, *nt;
218 struct net_device *dev;
219 char name[IFNAMSIZ];
220
221 for (tp = __ipip_bucket(parms); (t = *tp) != NULL; tp = &t->next) {
222 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
223 return t;
224 }
225 if (!create)
226 return NULL;
227
228 if (parms->name[0])
229 strlcpy(name, parms->name, IFNAMSIZ);
230 else
231 sprintf(name, "tunl%%d");
232
233 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
234 if (dev == NULL)
235 return NULL;
236
237 if (strchr(name, '%')) {
238 if (dev_alloc_name(dev, name) < 0)
239 goto failed_free;
240 }
241
242 nt = netdev_priv(dev);
243 dev->init = ipip_tunnel_init;
244 nt->parms = *parms;
245
246 if (register_netdevice(dev) < 0)
247 goto failed_free;
248
249 dev_hold(dev);
250 ipip_tunnel_link(nt);
251 return nt;
252
253 failed_free:
254 free_netdev(dev);
255 return NULL;
256 }
257
258 static void ipip_tunnel_uninit(struct net_device *dev)
259 {
260 if (dev == ipip_fb_tunnel_dev) {
261 write_lock_bh(&ipip_lock);
262 tunnels_wc[0] = NULL;
263 write_unlock_bh(&ipip_lock);
264 } else
265 ipip_tunnel_unlink(netdev_priv(dev));
266 dev_put(dev);
267 }
268
269 static int ipip_err(struct sk_buff *skb, u32 info)
270 {
271 #ifndef I_WISH_WORLD_WERE_PERFECT
272
273 /* It is not :-( All the routers (except for Linux) return only
274 8 bytes of packet payload. It means, that precise relaying of
275 ICMP in the real Internet is absolutely infeasible.
276 */
277 struct iphdr *iph = (struct iphdr*)skb->data;
278 const int type = icmp_hdr(skb)->type;
279 const int code = icmp_hdr(skb)->code;
280 struct ip_tunnel *t;
281 int err;
282
283 switch (type) {
284 default:
285 case ICMP_PARAMETERPROB:
286 return 0;
287
288 case ICMP_DEST_UNREACH:
289 switch (code) {
290 case ICMP_SR_FAILED:
291 case ICMP_PORT_UNREACH:
292 /* Impossible event. */
293 return 0;
294 case ICMP_FRAG_NEEDED:
295 /* Soft state for pmtu is maintained by IP core. */
296 return 0;
297 default:
298 /* All others are translated to HOST_UNREACH.
299 rfc2003 contains "deep thoughts" about NET_UNREACH,
300 I believe they are just ether pollution. --ANK
301 */
302 break;
303 }
304 break;
305 case ICMP_TIME_EXCEEDED:
306 if (code != ICMP_EXC_TTL)
307 return 0;
308 break;
309 }
310
311 err = -ENOENT;
312
313 read_lock(&ipip_lock);
314 t = ipip_tunnel_lookup(iph->daddr, iph->saddr);
315 if (t == NULL || t->parms.iph.daddr == 0)
316 goto out;
317
318 err = 0;
319 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
320 goto out;
321
322 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
323 t->err_count++;
324 else
325 t->err_count = 1;
326 t->err_time = jiffies;
327 out:
328 read_unlock(&ipip_lock);
329 return err;
330 #else
331 struct iphdr *iph = (struct iphdr*)dp;
332 int hlen = iph->ihl<<2;
333 struct iphdr *eiph;
334 const int type = icmp_hdr(skb)->type;
335 const int code = icmp_hdr(skb)->code;
336 int rel_type = 0;
337 int rel_code = 0;
338 __be32 rel_info = 0;
339 __u32 n = 0;
340 struct sk_buff *skb2;
341 struct flowi fl;
342 struct rtable *rt;
343
344 if (len < hlen + sizeof(struct iphdr))
345 return 0;
346 eiph = (struct iphdr*)(dp + hlen);
347
348 switch (type) {
349 default:
350 return 0;
351 case ICMP_PARAMETERPROB:
352 n = ntohl(icmp_hdr(skb)->un.gateway) >> 24;
353 if (n < hlen)
354 return 0;
355
356 /* So... This guy found something strange INSIDE encapsulated
357 packet. Well, he is fool, but what can we do ?
358 */
359 rel_type = ICMP_PARAMETERPROB;
360 rel_info = htonl((n - hlen) << 24);
361 break;
362
363 case ICMP_DEST_UNREACH:
364 switch (code) {
365 case ICMP_SR_FAILED:
366 case ICMP_PORT_UNREACH:
367 /* Impossible event. */
368 return 0;
369 case ICMP_FRAG_NEEDED:
370 /* And it is the only really necessary thing :-) */
371 n = ntohs(icmp_hdr(skb)->un.frag.mtu);
372 if (n < hlen+68)
373 return 0;
374 n -= hlen;
375 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
376 if (n > ntohs(eiph->tot_len))
377 return 0;
378 rel_info = htonl(n);
379 break;
380 default:
381 /* All others are translated to HOST_UNREACH.
382 rfc2003 contains "deep thoughts" about NET_UNREACH,
383 I believe, it is just ether pollution. --ANK
384 */
385 rel_type = ICMP_DEST_UNREACH;
386 rel_code = ICMP_HOST_UNREACH;
387 break;
388 }
389 break;
390 case ICMP_TIME_EXCEEDED:
391 if (code != ICMP_EXC_TTL)
392 return 0;
393 break;
394 }
395
396 /* Prepare fake skb to feed it to icmp_send */
397 skb2 = skb_clone(skb, GFP_ATOMIC);
398 if (skb2 == NULL)
399 return 0;
400 dst_release(skb2->dst);
401 skb2->dst = NULL;
402 skb_pull(skb2, skb->data - (u8*)eiph);
403 skb_reset_network_header(skb2);
404
405 /* Try to guess incoming interface */
406 memset(&fl, 0, sizeof(fl));
407 fl.fl4_daddr = eiph->saddr;
408 fl.fl4_tos = RT_TOS(eiph->tos);
409 fl.proto = IPPROTO_IPIP;
410 if (ip_route_output_key(&init_net, &rt, &key)) {
411 kfree_skb(skb2);
412 return 0;
413 }
414 skb2->dev = rt->u.dst.dev;
415
416 /* route "incoming" packet */
417 if (rt->rt_flags&RTCF_LOCAL) {
418 ip_rt_put(rt);
419 rt = NULL;
420 fl.fl4_daddr = eiph->daddr;
421 fl.fl4_src = eiph->saddr;
422 fl.fl4_tos = eiph->tos;
423 if (ip_route_output_key(&init_net, &rt, &fl) ||
424 rt->u.dst.dev->type != ARPHRD_TUNNEL) {
425 ip_rt_put(rt);
426 kfree_skb(skb2);
427 return 0;
428 }
429 } else {
430 ip_rt_put(rt);
431 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
432 skb2->dst->dev->type != ARPHRD_TUNNEL) {
433 kfree_skb(skb2);
434 return 0;
435 }
436 }
437
438 /* change mtu on this route */
439 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
440 if (n > dst_mtu(skb2->dst)) {
441 kfree_skb(skb2);
442 return 0;
443 }
444 skb2->dst->ops->update_pmtu(skb2->dst, n);
445 } else if (type == ICMP_TIME_EXCEEDED) {
446 struct ip_tunnel *t = netdev_priv(skb2->dev);
447 if (t->parms.iph.ttl) {
448 rel_type = ICMP_DEST_UNREACH;
449 rel_code = ICMP_HOST_UNREACH;
450 }
451 }
452
453 icmp_send(skb2, rel_type, rel_code, rel_info);
454 kfree_skb(skb2);
455 return 0;
456 #endif
457 }
458
459 static inline void ipip_ecn_decapsulate(const struct iphdr *outer_iph,
460 struct sk_buff *skb)
461 {
462 struct iphdr *inner_iph = ip_hdr(skb);
463
464 if (INET_ECN_is_ce(outer_iph->tos))
465 IP_ECN_set_ce(inner_iph);
466 }
467
468 static int ipip_rcv(struct sk_buff *skb)
469 {
470 struct ip_tunnel *tunnel;
471 const struct iphdr *iph = ip_hdr(skb);
472
473 read_lock(&ipip_lock);
474 if ((tunnel = ipip_tunnel_lookup(iph->saddr, iph->daddr)) != NULL) {
475 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
476 read_unlock(&ipip_lock);
477 kfree_skb(skb);
478 return 0;
479 }
480
481 secpath_reset(skb);
482
483 skb->mac_header = skb->network_header;
484 skb_reset_network_header(skb);
485 skb->protocol = htons(ETH_P_IP);
486 skb->pkt_type = PACKET_HOST;
487
488 tunnel->stat.rx_packets++;
489 tunnel->stat.rx_bytes += skb->len;
490 skb->dev = tunnel->dev;
491 dst_release(skb->dst);
492 skb->dst = NULL;
493 nf_reset(skb);
494 ipip_ecn_decapsulate(iph, skb);
495 netif_rx(skb);
496 read_unlock(&ipip_lock);
497 return 0;
498 }
499 read_unlock(&ipip_lock);
500
501 return -1;
502 }
503
504 /*
505 * This function assumes it is being called from dev_queue_xmit()
506 * and that skb is filled properly by that function.
507 */
508
509 static int ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
510 {
511 struct ip_tunnel *tunnel = netdev_priv(dev);
512 struct net_device_stats *stats = &tunnel->stat;
513 struct iphdr *tiph = &tunnel->parms.iph;
514 u8 tos = tunnel->parms.iph.tos;
515 __be16 df = tiph->frag_off;
516 struct rtable *rt; /* Route to the other host */
517 struct net_device *tdev; /* Device to other host */
518 struct iphdr *old_iph = ip_hdr(skb);
519 struct iphdr *iph; /* Our new IP header */
520 unsigned int max_headroom; /* The extra header space needed */
521 __be32 dst = tiph->daddr;
522 int mtu;
523
524 if (tunnel->recursion++) {
525 tunnel->stat.collisions++;
526 goto tx_error;
527 }
528
529 if (skb->protocol != htons(ETH_P_IP))
530 goto tx_error;
531
532 if (tos&1)
533 tos = old_iph->tos;
534
535 if (!dst) {
536 /* NBMA tunnel */
537 if ((rt = skb->rtable) == NULL) {
538 tunnel->stat.tx_fifo_errors++;
539 goto tx_error;
540 }
541 if ((dst = rt->rt_gateway) == 0)
542 goto tx_error_icmp;
543 }
544
545 {
546 struct flowi fl = { .oif = tunnel->parms.link,
547 .nl_u = { .ip4_u =
548 { .daddr = dst,
549 .saddr = tiph->saddr,
550 .tos = RT_TOS(tos) } },
551 .proto = IPPROTO_IPIP };
552 if (ip_route_output_key(&init_net, &rt, &fl)) {
553 tunnel->stat.tx_carrier_errors++;
554 goto tx_error_icmp;
555 }
556 }
557 tdev = rt->u.dst.dev;
558
559 if (tdev == dev) {
560 ip_rt_put(rt);
561 tunnel->stat.collisions++;
562 goto tx_error;
563 }
564
565 if (tiph->frag_off)
566 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
567 else
568 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
569
570 if (mtu < 68) {
571 tunnel->stat.collisions++;
572 ip_rt_put(rt);
573 goto tx_error;
574 }
575 if (skb->dst)
576 skb->dst->ops->update_pmtu(skb->dst, mtu);
577
578 df |= (old_iph->frag_off&htons(IP_DF));
579
580 if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
581 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
582 ip_rt_put(rt);
583 goto tx_error;
584 }
585
586 if (tunnel->err_count > 0) {
587 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
588 tunnel->err_count--;
589 dst_link_failure(skb);
590 } else
591 tunnel->err_count = 0;
592 }
593
594 /*
595 * Okay, now see if we can stuff it in the buffer as-is.
596 */
597 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
598
599 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
600 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
601 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
602 if (!new_skb) {
603 ip_rt_put(rt);
604 stats->tx_dropped++;
605 dev_kfree_skb(skb);
606 tunnel->recursion--;
607 return 0;
608 }
609 if (skb->sk)
610 skb_set_owner_w(new_skb, skb->sk);
611 dev_kfree_skb(skb);
612 skb = new_skb;
613 old_iph = ip_hdr(skb);
614 }
615
616 skb->transport_header = skb->network_header;
617 skb_push(skb, sizeof(struct iphdr));
618 skb_reset_network_header(skb);
619 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
620 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
621 IPSKB_REROUTED);
622 dst_release(skb->dst);
623 skb->dst = &rt->u.dst;
624
625 /*
626 * Push down and install the IPIP header.
627 */
628
629 iph = ip_hdr(skb);
630 iph->version = 4;
631 iph->ihl = sizeof(struct iphdr)>>2;
632 iph->frag_off = df;
633 iph->protocol = IPPROTO_IPIP;
634 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
635 iph->daddr = rt->rt_dst;
636 iph->saddr = rt->rt_src;
637
638 if ((iph->ttl = tiph->ttl) == 0)
639 iph->ttl = old_iph->ttl;
640
641 nf_reset(skb);
642
643 IPTUNNEL_XMIT();
644 tunnel->recursion--;
645 return 0;
646
647 tx_error_icmp:
648 dst_link_failure(skb);
649 tx_error:
650 stats->tx_errors++;
651 dev_kfree_skb(skb);
652 tunnel->recursion--;
653 return 0;
654 }
655
656 static void ipip_tunnel_bind_dev(struct net_device *dev)
657 {
658 struct net_device *tdev = NULL;
659 struct ip_tunnel *tunnel;
660 struct iphdr *iph;
661
662 tunnel = netdev_priv(dev);
663 iph = &tunnel->parms.iph;
664
665 if (iph->daddr) {
666 struct flowi fl = { .oif = tunnel->parms.link,
667 .nl_u = { .ip4_u =
668 { .daddr = iph->daddr,
669 .saddr = iph->saddr,
670 .tos = RT_TOS(iph->tos) } },
671 .proto = IPPROTO_IPIP };
672 struct rtable *rt;
673 if (!ip_route_output_key(&init_net, &rt, &fl)) {
674 tdev = rt->u.dst.dev;
675 ip_rt_put(rt);
676 }
677 dev->flags |= IFF_POINTOPOINT;
678 }
679
680 if (!tdev && tunnel->parms.link)
681 tdev = __dev_get_by_index(&init_net, tunnel->parms.link);
682
683 if (tdev) {
684 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
685 dev->mtu = tdev->mtu - sizeof(struct iphdr);
686 }
687 dev->iflink = tunnel->parms.link;
688 }
689
690 static int
691 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
692 {
693 int err = 0;
694 struct ip_tunnel_parm p;
695 struct ip_tunnel *t;
696
697 switch (cmd) {
698 case SIOCGETTUNNEL:
699 t = NULL;
700 if (dev == ipip_fb_tunnel_dev) {
701 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
702 err = -EFAULT;
703 break;
704 }
705 t = ipip_tunnel_locate(&p, 0);
706 }
707 if (t == NULL)
708 t = netdev_priv(dev);
709 memcpy(&p, &t->parms, sizeof(p));
710 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
711 err = -EFAULT;
712 break;
713
714 case SIOCADDTUNNEL:
715 case SIOCCHGTUNNEL:
716 err = -EPERM;
717 if (!capable(CAP_NET_ADMIN))
718 goto done;
719
720 err = -EFAULT;
721 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
722 goto done;
723
724 err = -EINVAL;
725 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
726 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
727 goto done;
728 if (p.iph.ttl)
729 p.iph.frag_off |= htons(IP_DF);
730
731 t = ipip_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
732
733 if (dev != ipip_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
734 if (t != NULL) {
735 if (t->dev != dev) {
736 err = -EEXIST;
737 break;
738 }
739 } else {
740 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
741 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
742 err = -EINVAL;
743 break;
744 }
745 t = netdev_priv(dev);
746 ipip_tunnel_unlink(t);
747 t->parms.iph.saddr = p.iph.saddr;
748 t->parms.iph.daddr = p.iph.daddr;
749 memcpy(dev->dev_addr, &p.iph.saddr, 4);
750 memcpy(dev->broadcast, &p.iph.daddr, 4);
751 ipip_tunnel_link(t);
752 netdev_state_change(dev);
753 }
754 }
755
756 if (t) {
757 err = 0;
758 if (cmd == SIOCCHGTUNNEL) {
759 t->parms.iph.ttl = p.iph.ttl;
760 t->parms.iph.tos = p.iph.tos;
761 t->parms.iph.frag_off = p.iph.frag_off;
762 if (t->parms.link != p.link) {
763 t->parms.link = p.link;
764 ipip_tunnel_bind_dev(dev);
765 netdev_state_change(dev);
766 }
767 }
768 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
769 err = -EFAULT;
770 } else
771 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
772 break;
773
774 case SIOCDELTUNNEL:
775 err = -EPERM;
776 if (!capable(CAP_NET_ADMIN))
777 goto done;
778
779 if (dev == ipip_fb_tunnel_dev) {
780 err = -EFAULT;
781 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
782 goto done;
783 err = -ENOENT;
784 if ((t = ipip_tunnel_locate(&p, 0)) == NULL)
785 goto done;
786 err = -EPERM;
787 if (t->dev == ipip_fb_tunnel_dev)
788 goto done;
789 dev = t->dev;
790 }
791 unregister_netdevice(dev);
792 err = 0;
793 break;
794
795 default:
796 err = -EINVAL;
797 }
798
799 done:
800 return err;
801 }
802
803 static struct net_device_stats *ipip_tunnel_get_stats(struct net_device *dev)
804 {
805 return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
806 }
807
808 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
809 {
810 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
811 return -EINVAL;
812 dev->mtu = new_mtu;
813 return 0;
814 }
815
816 static void ipip_tunnel_setup(struct net_device *dev)
817 {
818 dev->uninit = ipip_tunnel_uninit;
819 dev->hard_start_xmit = ipip_tunnel_xmit;
820 dev->get_stats = ipip_tunnel_get_stats;
821 dev->do_ioctl = ipip_tunnel_ioctl;
822 dev->change_mtu = ipip_tunnel_change_mtu;
823 dev->destructor = free_netdev;
824
825 dev->type = ARPHRD_TUNNEL;
826 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
827 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
828 dev->flags = IFF_NOARP;
829 dev->iflink = 0;
830 dev->addr_len = 4;
831 }
832
833 static int ipip_tunnel_init(struct net_device *dev)
834 {
835 struct ip_tunnel *tunnel;
836
837 tunnel = netdev_priv(dev);
838
839 tunnel->dev = dev;
840 strcpy(tunnel->parms.name, dev->name);
841
842 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
843 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
844
845 ipip_tunnel_bind_dev(dev);
846
847 return 0;
848 }
849
850 static int __init ipip_fb_tunnel_init(struct net_device *dev)
851 {
852 struct ip_tunnel *tunnel = netdev_priv(dev);
853 struct iphdr *iph = &tunnel->parms.iph;
854
855 tunnel->dev = dev;
856 strcpy(tunnel->parms.name, dev->name);
857
858 iph->version = 4;
859 iph->protocol = IPPROTO_IPIP;
860 iph->ihl = 5;
861
862 dev_hold(dev);
863 tunnels_wc[0] = tunnel;
864 return 0;
865 }
866
867 static struct xfrm_tunnel ipip_handler = {
868 .handler = ipip_rcv,
869 .err_handler = ipip_err,
870 .priority = 1,
871 };
872
873 static char banner[] __initdata =
874 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
875
876 static int ipip_init_net(struct net *net)
877 {
878 int err;
879 struct ipip_net *ipn;
880
881 err = -ENOMEM;
882 ipn = kmalloc(sizeof(struct ipip_net), GFP_KERNEL);
883 if (ipn == NULL)
884 goto err_alloc;
885
886 err = net_assign_generic(net, ipip_net_id, ipn);
887 if (err < 0)
888 goto err_assign;
889
890 return 0;
891
892 err_assign:
893 kfree(ipn);
894 err_alloc:
895 return err;
896 }
897
898 static void ipip_exit_net(struct net *net)
899 {
900 struct ipip_net *ipn;
901
902 ipn = net_generic(net, ipip_net_id);
903 kfree(ipn);
904 }
905
906 static struct pernet_operations ipip_net_ops = {
907 .init = ipip_init_net,
908 .exit = ipip_exit_net,
909 };
910
911 static int __init ipip_init(void)
912 {
913 int err;
914
915 printk(banner);
916
917 if (xfrm4_tunnel_register(&ipip_handler, AF_INET)) {
918 printk(KERN_INFO "ipip init: can't register tunnel\n");
919 return -EAGAIN;
920 }
921
922 ipip_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
923 "tunl0",
924 ipip_tunnel_setup);
925 if (!ipip_fb_tunnel_dev) {
926 err = -ENOMEM;
927 goto err1;
928 }
929
930 ipip_fb_tunnel_dev->init = ipip_fb_tunnel_init;
931
932 if ((err = register_netdev(ipip_fb_tunnel_dev)))
933 goto err2;
934
935 err = register_pernet_gen_device(&ipip_net_id, &ipip_net_ops);
936 if (err)
937 goto err3;
938 out:
939 return err;
940 err2:
941 free_netdev(ipip_fb_tunnel_dev);
942 err1:
943 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
944 goto out;
945 err3:
946 unregister_netdevice(ipip_fb_tunnel_dev);
947 goto err1;
948 }
949
950 static void __exit ipip_destroy_tunnels(void)
951 {
952 int prio;
953
954 for (prio = 1; prio < 4; prio++) {
955 int h;
956 for (h = 0; h < HASH_SIZE; h++) {
957 struct ip_tunnel *t;
958 while ((t = tunnels[prio][h]) != NULL)
959 unregister_netdevice(t->dev);
960 }
961 }
962 }
963
964 static void __exit ipip_fini(void)
965 {
966 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
967 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
968
969 rtnl_lock();
970 ipip_destroy_tunnels();
971 unregister_netdevice(ipip_fb_tunnel_dev);
972 rtnl_unlock();
973
974 unregister_pernet_gen_device(ipip_net_id, &ipip_net_ops);
975 }
976
977 module_init(ipip_init);
978 module_exit(ipip_fini);
979 MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)