1 /* tunnel.c: an IP tunnel driver 2
3 The purpose of this driver is to provide an IP tunnel through 4 which you can tunnel network traffic transparently across subnets. 5
6 This was written by looking at Nick Holloway's dummy driver 7 Thanks for the great code! 8
9 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95 10 11 Minor tweaks: 12 Cleaned up the code a little and added some pre-1.3.0 tweaks. 13 dev->hard_header/hard_header_len changed to use no headers. 14 Comments/bracketing tweaked. 15 Made the tunnels use dev->name not tunnel: when error reporting. 16 Added tx_dropped stat 17 18 -Alan Cox (Alan.Cox@linux.org) 21 March 95 19
20 Reworked: 21 Changed to tunnel to destination gateway instead of pointopoint 22 Almost completely rewritten 23 Note: There is currently no firewall or ICMP handling done. 24
25 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96 26 27 Note: 28 The old driver is in tunnel.c if you have funnies with the 29 new one. 30 */ 31
32 /* Things I wish I had known when writing the tunnel driver: 33
34 When the tunnel_xmit() function is called, the skb contains the 35 packet to be sent (plus a great deal of extra info), and dev 36 contains the tunnel device that _we_ are. 37
38 When we are passed a packet, we are expected to fill in the 39 source address with our source IP address. 40
41 What is the proper way to allocate, copy and free a buffer? 42 After you allocate it, it is a "0 length" chunk of memory 43 starting at zero. If you want to add headers to the buffer 44 later, you'll have to call "skb_reserve(skb, amount)" with 45 the amount of memory you want reserved. Then, you call 46 "skb_put(skb, amount)" with the amount of space you want in 47 the buffer. skb_put() returns a pointer to the top (#0) of 48 that buffer. skb->len is set to the amount of space you have 49 "allocated" with skb_put(). You can then write up to skb->len 50 bytes to that buffer. If you need more, you can call skb_put() 51 again with the additional amount of space you need. You can 52 find out how much more space you can allocate by calling 53 "skb_tailroom(skb)". 54 Now, to add header space, call "skb_push(skb, header_len)". 55 This creates space at the beginning of the buffer and returns 56 a pointer to this new space. If later you need to strip a 57 header from a buffer, call "skb_pull(skb, header_len)". 58 skb_headroom() will return how much space is left at the top 59 of the buffer (before the main data). Remember, this headroom 60 space must be reserved before the skb_put() function is called. 61 */ 62
63 #include <linux/module.h>
64
65 /* Only two headers!! :-) */ 66 #include <net/ip.h>
67 #include <linux/if_arp.h>
68
69
70 /*#define TUNNEL_DEBUG*/ 71
72 /* 73 * Our header is a simple IP packet with no options 74 */ 75
76 #definetunnel_hlensizeof(structiphdr)
77
78 /* 79 * Okay, this needs to be high enough that we can fit a "standard" 80 * ethernet header and an IP tunnel header into the outgoing packet. 81 * [36 bytes] 82 */ 83
84 #defineTUNL_HLEN (((ETH_HLEN+15)&~15)+tunl_hlen)
85
86
87 #ifdefMODULE 88 staticinttunnel_open(structdevice *dev)
/* */ 89 { 90 MOD_INC_USE_COUNT;
91 return 0;
92 } 93
94 staticinttunnel_close(structdevice *dev)
/* */ 95 { 96 MOD_DEC_USE_COUNT;
97 return 0;
98 } 99
100 #endif 101
102 #ifdefTUNNEL_DEBUG 103 voidprint_ip(structiphdr *ip)
/* */ 104 { 105 unsignedchar *ipaddr;
106
107 printk("IP packet:\n");
108 printk("--- header len = %d\n", ip->ihl*4);
109 printk("--- ip version: %d\n", ip->version);
110 printk("--- ip protocol: %d\n", ip->protocol);
111 ipaddr=(unsignedchar *)&ip->saddr;
112 printk("--- source address: %u.%u.%u.%u\n",
113 *ipaddr, *(ipaddr+1), *(ipaddr+2), *(ipaddr+3));
114 ipaddr=(unsignedchar *)&ip->daddr;
115 printk("--- destination address: %u.%u.%u.%u\n",
116 *ipaddr, *(ipaddr+1), *(ipaddr+2), *(ipaddr+3));
117 printk("--- total packet len: %d\n", ntohs(ip->tot_len));
118 } 119 #endif 120
121 /* 122 * This function assumes it is being called from dev_queue_xmit() 123 * and that skb is filled properly by that function. 124 */ 125
126 staticinttunnel_xmit(structsk_buff *skb, structdevice *dev)
/* */ 127 { 128 structenet_statistics *stats; /* This device's statistics */ 129 structrtable *rt; /* Route to the other host */ 130 structdevice *tdev; /* Device to other host */ 131 structiphdr *iph; /* Our new IP header */ 132 __u32target; /* The other host's IP address */ 133 intmax_headroom; /* The extra header space needed */ 134
135 /* 136 * Return if there is nothing to do. (Does this ever happen?) 137 */ 138 if (skb == NULL || dev == NULL) { 139 #ifdefTUNNEL_DEBUG 140 printk ( KERN_INFO "tunnel: Nothing to do!\n" );
141 #endif 142 return 0;
143 } 144
145 /* 146 * Make sure we are not busy (check lock variable) 147 */ 148
149 stats = (structenet_statistics *)dev->priv;
150 cli();
151 if (dev->tbusy != 0)
152 { 153 sti();
154 stats->tx_errors++;
155 return(1);
156 } 157 dev->tbusy = 1;
158 sti();
159
160 /*printk("-");*/ 161 /* 162 * First things first. Look up the destination address in the 163 * routing tables 164 */ 165 iph = (structiphdr *) skb->data;
166 if ((rt = ip_rt_route(iph->daddr, 0)) == NULL)
167 { 168 /* No route to host */ 169 /* Where did the packet come from? */ 170 /*icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);*/ 171 printk ( KERN_INFO "%s: Packet with no route!\n", dev->name );
172 dev->tbusy=0;
173 stats->tx_errors++;
174 return(1);
175 } 176
177 if (!(rt->rt_flags & RTF_GATEWAY))
178 { 179 /* No gateway to tunnel through? */ 180 /* Where did the packet come from? */ 181 /*icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);*/ 182 printk ( KERN_INFO "%s: Packet with no target gateway!\n", dev->name);
183 ip_rt_put(rt);
184 dev->tbusy=0;
185 stats->tx_errors++;
186 return(1);
187 } 188 target = rt->rt_gateway;
189 ip_rt_put(rt);
190
191 if ((rt = ip_rt_route(target, 0)) == NULL)
192 { 193 /* No route to host */ 194 /* Where did the packet come from? */ 195 /*icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);*/ 196 printk ( KERN_INFO "%s: Can't reach target gateway!\n", dev->name);
197 dev->tbusy=0;
198 stats->tx_errors++;
199 return(1);
200 } 201 tdev = rt->rt_dev;
202
203 if (tdev == dev)
204 { 205 /* Tunnel to ourselves? -- I don't think so. */ 206 printk ( KERN_INFO "%s: Packet targetted at myself!\n" ,dev->name);
207 ip_rt_put(rt);
208 dev->tbusy=0;
209 stats->tx_errors++;
210 return(1);
211 } 212
213 #ifdefTUNNEL_DEBUG 214 printk("Old IP Header....\n");
215 print_ip(iph);
216 #endif 217
218 /* 219 * Okay, now see if we can stuff it in the buffer as-is. 220 */ 221 max_headroom = ((tunnel_hlen+tdev->hard_header_len+15)&~15);
222 #ifdefTUNNEL_DEBUG 223 printk("Room left at head: %d\n", skb_headroom(skb));
224 printk("Room left at tail: %d\n", skb_tailroom(skb));
225 printk("Required room: %d, Tunnel hlen: %d\n", max_headroom, TUNL_HLEN);
226 #endif 227 if (skb_headroom(skb) >= max_headroom) { 228 skb->h.iph = (structiphdr *) skb_push(skb, tunnel_hlen);
229 }else{ 230 structsk_buff *new_skb;
231
232 if ( !(new_skb = dev_alloc_skb(skb->len+max_headroom)) )
233 { 234 printk( KERN_INFO "%s: Out of memory, dropped packet\n",
235 dev->name);
236 ip_rt_put(rt);
237 dev->tbusy = 0;
238 stats->tx_dropped++;
239 return(1);
240 } 241 new_skb->free = 1;
242
243 /* 244 * Reserve space for our header 245 */ 246 skb_reserve(new_skb, tunnel_hlen);
247 new_skb->h.iph = (structiphdr *) skb_push(new_skb, tunnel_hlen);
248 /* 249 * Copy the old packet to the new buffer. 250 * Note that new_skb->h.iph is our (tunnel driver's) header 251 * and new_skb->ip_hdr is the IP header of the old packet. 252 */ 253 new_skb->ip_hdr = (structiphdr *) skb_put(new_skb, skb->len);
254 memcpy(new_skb->ip_hdr, skb->data, skb->len);
255 /* Is this necessary? */ 256 memcpy(new_skb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
257
258 /* Free the old packet, we no longer need it */ 259 kfree_skb(skb, FREE_WRITE);
260 skb = new_skb;
261 } 262
263 /* 264 * Push down and install the IPIP header. 265 */ 266 iph = skb->h.iph;
267 iph->version = 4;
268 iph->tos = skb->ip_hdr->tos;
269 iph->ttl = skb->ip_hdr->ttl;
270 iph->frag_off = 0;
271 iph->daddr = target;
272 iph->saddr = tdev->pa_addr;
273 iph->protocol = IPPROTO_IPIP;
274 iph->ihl = 5;
275 iph->tot_len = htons(skb->len);
276 iph->id = htons(ip_id_count++); /* Race condition here? */ 277 ip_send_check(iph);
278 skb->ip_hdr = skb->h.iph;
279
280 #ifdefTUNNEL_DEBUG 281 printk("New IP Header....\n");
282 print_ip(iph);
283 #endif 284
285 /* 286 * Send the packet on its way! 287 * Note that dev_queue_xmit() will eventually free the skb. 288 * If ip_forward() made a copy, it will return 1 so we can free. 289 */ 290
291 if (ip_forward(skb, dev, 0, target) == 1)
292 kfree_skb(skb, FREE_WRITE);
293
294 /* 295 * Clean up: We're done with the route and the packet 296 */ 297
298 ip_rt_put(rt);
299
300 #ifdefTUNNEL_DEBUG 301 printk("Packet sent through tunnel interface!\n");
302 #endif 303 /*printk(">");*/ 304 /* Record statistics and return */ 305 stats->tx_packets++;
306 dev->tbusy=0;
307 return 0;
308 } 309
310 staticstructenet_statistics *
311 tunnel_get_stats(structdevice *dev)
/* */ 312 { 313 return((structenet_statistics*) dev->priv);
314 } 315
316 /* 317 * Called when a new tunnel device is initialized. 318 * The new tunnel device structure is passed to us. 319 */ 320
321 inttunnel_init(structdevice *dev)
/* */ 322 { 323 inti;
324
325 /* Oh, just say we're here, in case anyone cares */ 326 staticinttun_msg=0;
327 if(!tun_msg)
328 { 329 printk ( KERN_INFO "tunnel: version v0.2b\n" );
330 tun_msg=1;
331 } 332
333 /* Add our tunnel functions to the device */ 334 #ifdefMODULE 335 dev->open = tunnel_open;
336 dev->stop = tunnel_close;
337 #endif 338 dev->hard_start_xmit = tunnel_xmit;
339 dev->get_stats = tunnel_get_stats;
340 dev->priv = kmalloc(sizeof(structenet_statistics), GFP_KERNEL);
341 if (dev->priv == NULL)
342 return -ENOMEM;
343 memset(dev->priv, 0, sizeof(structenet_statistics));
344
345 /* Initialize the tunnel device structure */ 346 for (i = 0; i < DEV_NUMBUFFS; i++)
347 skb_queue_head_init(&dev->buffs[i]);
348
349 dev->hard_header = NULL;
350 dev->rebuild_header = NULL;
351 dev->set_mac_address = NULL;
352 dev->header_cache_bind = NULL;
353 dev->header_cache_update= NULL;
354
355 dev->type = ARPHRD_TUNNEL;
356 dev->hard_header_len = (tunnel_hlen+ETH_HLEN);
357 dev->mtu = 1500-tunnel_hlen; /* eth_mtu */ 358 dev->addr_len = 0; /* Is this only for ARP? */ 359 dev->tx_queue_len = 2; /* Small queue */ 360
361 /* it should all run through */ 362 memset(dev->broadcast,0xFF, ETH_ALEN);
363
364 /* New-style flags. */ 365 dev->flags = IFF_NOARP; /* Don't use ARP on this device */ 366 /* No broadcasting through a tunnel */ 367 dev->family = AF_INET;
368 dev->pa_addr = 0;
369 dev->pa_brdaddr = 0;
370 dev->pa_mask = 0;
371 dev->pa_alen = 4;
372
373 /* We're done. Have I forgotten anything? */ 374 return 0;
375 } 376
377 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 378 /* Module specific interface */ 379 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 380 #ifdefMODULE 381
382 staticinttunnel_probe(structdevice *dev)
/* */ 383 { 384 tunnel_init(dev);
385 return 0;
386 } 387
388 staticstructdevicedev_tunnel = { 389 "tunl0\0 ",
390 0, 0, 0, 0,
391 0x0, 0,
392 0, 0, 0, NULL, tunnel_probe};
393
394 intinit_module(void)
/* */ 395 { 396 /* Find a name for this unit */ 397 intct= 1;
398
399 while(dev_get(dev_tunnel.name)!=NULL && ct<100)
400 { 401 sprintf(dev_tunnel.name,"tunl%d",ct);
402 ct++;
403 } 404
405 #ifdefTUNNEL_DEBUG 406 printk("tunnel: registering device %s\n", dev_tunnel.name);
407 #endif 408 if (register_netdev(&dev_tunnel) != 0)
409 return -EIO;
410 return 0;
411 } 412
413 voidcleanup_module(void)
/* */ 414 { 415 unregister_netdev(&dev_tunnel);
416 kfree_s(dev_tunnel.priv,sizeof(structenet_statistics));
417 dev_tunnel.priv=NULL;
418 } 419 #endif/* MODULE */ 420
421
422
423
424
425
426
427