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