home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / drivers / net / dummy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-23  |  3.7 KB  |  176 lines
  1. /* dummy.c: a dummy net driver
  2.  
  3.     The purpose of this driver is to provide a device to point a
  4.     route through, but not to actually transmit packets.
  5.  
  6.     Why?  If you have a machine whose only connection is an occasional
  7.     PPP/SLIP/PLIP link, you can only connect to your own hostname
  8.     when the link is up.  Otherwise you have to use localhost.
  9.     This isn't very consistent.
  10.  
  11.     One solution is to set up a dummy link using PPP/SLIP/PLIP,
  12.     but this seems (to me) too much overhead for too little gain.
  13.     This driver provides a small alternative. Thus you can do
  14.     
  15.     [when not running slip]
  16.         ifconfig dummy slip.addr.ess.here up
  17.     [to go to slip]
  18.         ifconfig dummy down
  19.         dip whatever
  20.  
  21.     This was written by looking at Donald Becker's skeleton driver
  22.     and the loopback driver.  I then threw away anything that didn't
  23.     apply!    Thanks to Alan Cox for the key clue on what to do with
  24.     misguided packets.
  25.  
  26.             Nick Holloway, 27th May 1994
  27.     [I tweaked this explanation a little but thats all]
  28.             Alan Cox, 30th May 1994
  29. */
  30.  
  31. /* To have statistics (just packets sent) define this */
  32. #undef DUMMY_STATS
  33.  
  34. #ifdef MODULE
  35. #include <linux/module.h>
  36. #include <linux/version.h>
  37. #endif
  38.  
  39. #include <linux/kernel.h>
  40. #include <linux/sched.h>
  41. #include <linux/types.h>
  42. #include <linux/fcntl.h>
  43. #include <linux/interrupt.h>
  44. #include <linux/ptrace.h>
  45. #include <linux/ioport.h>
  46. #include <linux/in.h>
  47. #include <linux/malloc.h>
  48. #include <linux/string.h>
  49. #include <asm/system.h>
  50. #include <asm/bitops.h>
  51. #include <asm/io.h>
  52. #include <asm/dma.h>
  53. #include <linux/errno.h>
  54.  
  55. #include <linux/netdevice.h>
  56. #include <linux/etherdevice.h>
  57. #include <linux/skbuff.h>
  58.  
  59. static int dummy_xmit(struct sk_buff *skb, struct device *dev);
  60. #ifdef DUMMY_STATS
  61. static struct enet_statistics *dummy_get_stats(struct device *dev);
  62. #endif
  63.  
  64. #ifdef MODULE
  65. static int dummy_open(struct device *dev)
  66. {
  67.     MOD_INC_USE_COUNT;
  68.     return 0;
  69. }
  70.  
  71. static int dummy_close(struct device *dev)
  72. {
  73.     MOD_DEC_USE_COUNT;
  74.     return 0;
  75. }
  76.  
  77. #endif
  78.  
  79.  
  80. int dummy_init(struct device *dev)
  81. {
  82. /* I commented this out as bootup is noisy enough anyway and this driver
  83.    seems pretty reliable 8) 8) 8) */
  84. /*    printk ( KERN_INFO "Dummy net driver (94/05/27 v1.0)\n" ); */
  85.  
  86.     /* Initialize the device structure. */
  87.     dev->hard_start_xmit    = dummy_xmit;
  88.  
  89. #if DUMMY_STATS
  90.     dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
  91.     memset(dev->priv, 0, sizeof(struct enet_statistics));
  92.     dev->get_stats        = dummy_get_stats;
  93. #endif
  94. #ifdef MODULE
  95.     dev->open = &dummy_open;
  96.     dev->stop = &dummy_close;
  97. #endif
  98.  
  99.     /* Fill in the fields of the device structure with ethernet-generic values. */
  100.     ether_setup(dev);
  101.     dev->flags |= IFF_NOARP;
  102.  
  103.     return 0;
  104. }
  105.  
  106. static int
  107. dummy_xmit(struct sk_buff *skb, struct device *dev)
  108. {
  109. #if DUMMY_STATS
  110.     struct enet_statistics *stats;
  111. #endif
  112.  
  113.     if (skb == NULL || dev == NULL)
  114.         return 0;
  115.  
  116.     dev_kfree_skb(skb, FREE_WRITE);
  117.  
  118. #if DUMMY_STATS
  119.     stats = (struct enet_statistics *)dev->priv;
  120.     stats->tx_packets++;
  121. #endif
  122.  
  123.     return 0;
  124. }
  125.  
  126. #if DUMMY_STATS
  127. static struct enet_statistics *
  128. dummy_get_stats(struct device *dev)
  129. {
  130.     struct enet_statistics *stats = (struct enet_statistics*) dev->priv;
  131.     return stats;
  132. }
  133. #endif
  134.  
  135. #ifdef MODULE
  136. char kernel_version[] = UTS_RELEASE;
  137.  
  138. static int dummy_probe(struct device *dev)
  139. {
  140.     dummy_init(dev);
  141.     return 0;
  142. }
  143.  
  144. static struct device dev_dummy = {
  145.     "dummy0\0   ", 
  146.         0, 0, 0, 0,
  147.          0x0, 0,
  148.          0, 0, 0, NULL, dummy_probe };
  149.  
  150. int init_module(void)
  151. {
  152.     /* Find a name for this unit */
  153.     int ct= 1;
  154.     
  155.     while(dev_get(dev_dummy.name)!=NULL && ct<100)
  156.     {
  157.         sprintf(dev_dummy.name,"dummy%d",ct);
  158.         ct++;
  159.     }
  160.     
  161.     if (register_netdev(&dev_dummy) != 0)
  162.         return -EIO;
  163.     return 0;
  164. }
  165.  
  166. void cleanup_module(void)
  167. {
  168.     if (MOD_IN_USE)
  169.         printk("dummy: device busy, remove delayed\n");
  170.     else
  171.     {
  172.         unregister_netdev(&dev_dummy);
  173.     }
  174. }
  175. #endif /* MODULE */
  176.