tunif.c.rej

lwIP-Softools-11Jul2002-alpha

***************
*** 30,160 ****
   * 
   * Author: Adam Dunkels <[e-mail]>
   *
-  * $Id: tunif.c,v 1.1 2001/12/12 10:02:27 adam Exp $
   */
  
- #include "lwip/debug.h"
- 
  #include <fcntl.h>
  #include <stdlib.h>
  #include <stdio.h>
  #include <unistd.h>
- #include <sys/ioctl.h>
- #include <sys/socket.h>
  #include <sys/types.h>
  #include <sys/uio.h>
  #include <sys/socket.h>
- #ifndef linux
- #include <net/if_tun.h>
- #endif /* linux */
  
  #include "lwip/opt.h"
  #include "lwip/def.h"
  #include "lwip/mem.h"
- /*#include "lwip/ip.h"*/
  #include "lwip/pbuf.h"
- #include "netif/tunif.h"
  #include "lwip/sys.h"
- #include "lwip/err.h"
  
- /*efine TUNIF_DROP*/
  
  struct tunif {
    int fd;
  };
- static char buf[4096];
  
  /*-----------------------------------------------------------------------------------*/
  static void
- tunif_irq_handler(int fd, void *data)
  {
-   struct netif *netif;
-   struct tunif *tun;
-   char *bufp;
-   int len;
-   struct pbuf *p, *q;
  
-   netif = data;
-   tun = netif->state;
  
-   len = sizeof(buf);
-   len = read(tun->fd, buf, len);  
- #ifdef TUNIF_DROP  
-   if(((double)rand()/(double)RAND_MAX) < 0.10) {
-     DEBUGF(TUNIF_DEBUG, ("+++tunif_irq_handler: Packet dropped\n"));
-     return;
-   }
- #endif /* TUNIF_DROP */
-     
-   p = pbuf_alloc(PBUF_LINK, len, PBUF_POOL);
-   bufp = &buf[0];
-   for(q = p; q != NULL; q = q->next) {
-     bcopy(bufp, q->payload, q->len);
-     bufp += q->len;
-   }
-   if(p != NULL) {
- #ifdef IPv6        
-     pbuf_header(p, -4);
- #endif /* IPv6 */
-     netif->input(p, netif);
    }
    
  
  }
  /*-----------------------------------------------------------------------------------*/
  static err_t
- tunif_output(struct netif *netif, struct pbuf *p, struct ip_addr *ipaddr)
  {
-   struct tunif *tunif;
-   char *data;
    struct pbuf *q;
-   int i, j, ret;
- 
    
- #ifdef TUNIF_DROP
-   if(((double)rand()/(double)RAND_MAX) < 0.1) {
-     DEBUGF(TUNIF_DEBUG, ("+++tunif_output: Packet dropped\n"));
-     return 1;
-   }
- #endif /* TUNIF_DROP */
- 
-   tunif = netif->state;
-   data = malloc(p->tot_len);
- 
-   i = 0;
    for(q = p; q != NULL; q = q->next) {
-     for(j = 0; j < q->len; j++) {
-       data[i] = ((char *)q->payload)[j];
-       i++;
-     }
    }
  
-   DEBUGF(TUNIF_DEBUG, ("tunif: Sending len %d\n", p->tot_len));
- 
- #ifdef IPv4
-   ret = write(tunif->fd, data, p->tot_len);
- #else
-   {
-     struct iovec iov[2];
-     int af;
- 
-     printf("hahaha\n");
-     af = AF_INET6;
-     iov[0].iov_base = (char *)&af;
-     iov[0].iov_len  = sizeof(af);
-     iov[1].iov_base = data;
-     iov[1].iov_len  = p->tot_len;
-     
-     ret = writev(tunif->fd, iov, 2);
    }
- #endif /* IPv4 */
    
-   if(ret == -1) {
-     perror("tunif_output: write");
    }
-   free(data);
-   return 1;
  
  }
  /*-----------------------------------------------------------------------------------*/
  static void 
--- 30,193 ----
   * 
   * Author: Adam Dunkels <[e-mail]>
   *
+  * $Id: tunif.c,v 1.2 2002/01/02 15:51:44 adam Exp $
   */
  
  #include <fcntl.h>
  #include <stdlib.h>
  #include <stdio.h>
+ #include <string.h>
  #include <unistd.h>
  #include <sys/types.h>
  #include <sys/uio.h>
  #include <sys/socket.h>
+ 
+ 
+ #include "lwip/debug.h"
  
  #include "lwip/opt.h"
  #include "lwip/def.h"
+ #include "lwip/ip.h"
  #include "lwip/mem.h"
+ #include "lwip/netif.h"
  #include "lwip/pbuf.h"
  #include "lwip/sys.h"
  
+ 
+ #define IFNAME0 't'
+ #define IFNAME1 'n'
  
  struct tunif {
+   /* Add whatever per-interface state that is needed here. */
    int fd;
  };
+ 
+ /* Forward declarations. */
+ static void  tunif_input(struct netif *netif);
+ static err_t tunif_output(struct netif *netif, struct pbuf *p,
+ 			       struct ip_addr *ipaddr);
+ 
+ static void tunif_thread(void *data);
  
  /*-----------------------------------------------------------------------------------*/
  static void
+ low_level_init(struct netif *netif)
  {
+   struct tunif *tunif;
+   char buf[100];
  
+   tunif = netif->state;
+   
+   /* Obtain MAC address from network interface. */
  
+   /* Do whatever else is needed to initialize interface. */
+   
+   tunif->fd = open("/dev/tun0", O_RDWR);
+   DEBUGF(TUNIF_DEBUG, ("tunif_init: fd %d\n", tunif->fd));
+   if(tunif->fd == -1) {
+     perror("tunif_init");
+     exit(1);
    }
+   snprintf(buf, sizeof(buf), "ifconfig tun0 inet %d.%d.%d.%d %d.%d.%d.%d",
+            ip4_addr1(&(netif->gw)),
+            ip4_addr2(&(netif->gw)),
+            ip4_addr3(&(netif->gw)),
+            ip4_addr4(&(netif->gw)),
+            ip4_addr1(&(netif->ip_addr)),
+            ip4_addr2(&(netif->ip_addr)),
+            ip4_addr3(&(netif->ip_addr)),
+            ip4_addr4(&(netif->ip_addr)));
    
+   DEBUGF(TUNIF_DEBUG, ("tunif_init: system(\"%s\");\n", buf));
+   system(buf);
+   sys_thread_new(tunif_thread, netif);
  
  }
  /*-----------------------------------------------------------------------------------*/
+ /*
+  * low_level_output():
+  *
+  * Should do the actual transmission of the packet. The packet is
+  * contained in the pbuf that is passed to the function. This pbuf
+  * might be chained.
+  *
+  */
+ /*-----------------------------------------------------------------------------------*/
+ 
  static err_t
+ low_level_output(struct tunif *tunif, struct pbuf *p)
  {
    struct pbuf *q;
+   char buf[1500];
+   char *bufptr;
+   
+   /* initiate transfer(); */
+   
+   bufptr = &buf[0];
    
    for(q = p; q != NULL; q = q->next) {
+     /* Send the data from the pbuf to the interface, one pbuf at a
+        time. The size of the data in each pbuf is kept in the ->len
+        variable. */    
+     /* send data from(q->payload, q->len); */
+     bcopy(q->payload, bufptr, q->len);
+     bufptr += q->len;
    }
  
+   /* signal that packet should be sent(); */
+   if(write(tunif->fd, buf, p->tot_len) == -1) {
+     perror("tunif: write");
    }
+   return ERR_OK;
+ }
+ /*-----------------------------------------------------------------------------------*/
+ /*
+  * low_level_input():
+  *
+  * Should allocate a pbuf and transfer the bytes of the incoming
+  * packet from the interface into the pbuf.
+  *
+  */
+ /*-----------------------------------------------------------------------------------*/
+ static struct pbuf *
+ low_level_input(struct tunif *tunif)
+ {
+   struct pbuf *p, *q;
+   u16_t len;
+   char buf[1500];
+   char *bufptr;
+ 
+   /* Obtain the size of the packet and put it into the "len"
+      variable. */
+   len = read(tunif->fd, buf, sizeof(buf));
+ 
+   /*  if(((double)rand()/(double)RAND_MAX) < 0.1) {
+     printf("drop\n");
+     return NULL;
+     }*/
+ 
+   
+   /* We allocate a pbuf chain of pbufs from the pool. */
+   p = pbuf_alloc(PBUF_LINK, len, PBUF_POOL);
    
+   if(p != NULL) {
+     /* We iterate over the pbuf chain until we have read the entire
+        packet into the pbuf. */
+     bufptr = &buf[0];
+     for(q = p; q != NULL; q = q->next) {
+       /* Read enough bytes to fill this pbuf in the chain. The
+          avaliable data in the pbuf is given by the q->len
+          variable. */
+       /* read data into(q->payload, q->len); */
+       bcopy(bufptr, q->payload, q->len);
+       bufptr += q->len;
+     }
+     /* acknowledge that packet has been read(); */
+   } else {
+     /* drop packet(); */
    }
  
+   return p;  
  }
  /*-----------------------------------------------------------------------------------*/
  static void 
***************
*** 162,239 ****
  {
    struct netif *netif;
    struct tunif *tunif;
- 
-   DEBUGF(TUNIF_DEBUG, ("tunif_thread: started.\n"));
- 
    netif = arg;
    tunif = netif->state;
    
-   sys_irq(tunif->fd, tunif_irq_handler, netif);
-   sys_main();
  }
  /*-----------------------------------------------------------------------------------*/
- void
- tunif_init_thread(struct netif *netif)
  {
-   struct tunif *tun;
-   int val;
-   
-   tun = malloc(sizeof(struct tunif));
-   netif->state = tun;
-   netif->name[0] = 't';
-   netif->name[1] = 'n';
-   netif->output = tunif_output;
  
-   tun = netif->state;
-   tun->fd = open("/dev/tun0", O_RDWR);
-   if(tun->fd == -1) {
-     perror("tunif_init");
-     exit(1);
-   }
- #ifdef linux
-   /*  system("ifconfig tun0 10.0.0.1 pointopoint 10.0.0.2");
-       system("route add -net 10.0.0.0 netmask 255.0.0.0 tun0");*/
-   snprintf(buf, sizeof(buf), "ifconfig tun0 inet %d.%d.%d.%d %d.%d.%d.%d",
- 	   ip4_addr1(&(netif->ip_addr)),
- 	   ip4_addr2(&(netif->ip_addr)),
- 	   ip4_addr3(&(netif->ip_addr)),
- 	   ip4_addr4(&(netif->ip_addr)),
- 	   ip4_addr1(&(netif->gw)),
- 	   ip4_addr2(&(netif->gw)),
- 	   ip4_addr3(&(netif->gw)),
- 	   ip4_addr4(&(netif->gw)));
-   DEBUGF(TAPIF_DEBUG, ("tapif_init: system(\"%s\");\n", buf));
-   system(buf);
  
-   snprintf(buf, sizeof(buf), "route add -net %d.%d.0.0 netmask 255.255.0.0 dev tun0",
- 	   ip4_addr1(&(netif->ip_addr)),
- 	   ip4_addr2(&(netif->ip_addr)));  
-   DEBUGF(TAPIF_DEBUG, ("tapif_init: system(\"%s\");\n", buf));
-   system(buf);
- #else
- #ifdef IPv4  
-   snprintf(buf, sizeof(buf), "ifconfig tun0 inet %d.%d.%d.%d %d.%d.%d.%d",
- 	   ip4_addr1(&(netif->gw)),
- 	   ip4_addr2(&(netif->gw)),
- 	   ip4_addr3(&(netif->gw)),
- 	   ip4_addr4(&(netif->gw)),
- 	   ip4_addr1(&(netif->ip_addr)),
- 	   ip4_addr2(&(netif->ip_addr)),
- 	   ip4_addr3(&(netif->ip_addr)),
- 	   ip4_addr4(&(netif->ip_addr)));
-   val = 0;
-   ioctl(tun->fd, TUNSIFHEAD, &val);
- #else
-   snprintf(buf, sizeof(buf), "ifconfig tun0 inet6 fec0:0:0:1:2c0:6cff:fe00:f043");
-   val = 1;
-   ioctl(tun->fd, TUNSIFHEAD, &val);
- #endif /* IPv4 */  
-   DEBUGF(TUNIF_DEBUG, ("tunif_init: system(\"%s\");\n", buf));
-   system(buf);
- #endif /* linux */
  
-    
-   sys_thread_new(tunif_thread, netif);
  }
  /*-----------------------------------------------------------------------------------*/
  
--- 195,295 ----
  {
    struct netif *netif;
    struct tunif *tunif;
+   fd_set fdset;
+   int ret;
+   
    netif = arg;
    tunif = netif->state;
    
+   while(1) {
+     FD_ZERO(&fdset);
+     FD_SET(tunif->fd, &fdset);
+ 
+     /* Wait for a packet to arrive. */
+     ret = select(tunif->fd + 1, &fdset, NULL, NULL, NULL);
+ 
+     if(ret == 1) {
+       /* Handle incoming packet. */
+       tunif_input(netif);
+     } else if(ret == -1) {
+       perror("tunif_thread: select");
+     }
+   }
  }
  /*-----------------------------------------------------------------------------------*/
+ /*
+  * tunif_output():
+  *
+  * This function is called by the TCP/IP stack when an IP packet
+  * should be sent. It calls the function called low_level_output() to
+  * do the actuall transmission of the packet.
+  *
+  */
+ /*-----------------------------------------------------------------------------------*/
+ static err_t
+ tunif_output(struct netif *netif, struct pbuf *p,
+ 		  struct ip_addr *ipaddr)
  {
+   struct tunif *tunif;
  
+   tunif = netif->state;
  
+   return low_level_output(tunif, p);
  
  }
  /*-----------------------------------------------------------------------------------*/
+ /*
+  * tunif_input():
+  *
+  * This function should be called when a packet is ready to be read
+  * from the interface. It uses the function low_level_input() that
+  * should handle the actual reception of bytes from the network
+  * interface.
+  *
+  */
+ /*-----------------------------------------------------------------------------------*/
+ static void
+ tunif_input(struct netif *netif)
+ {
+   struct tunif *tunif;
+   struct pbuf *p;
  
+ 
+   tunif = netif->state;
+   
+   p = low_level_input(tunif);
+ 
+   if(p == NULL) {
+     DEBUGF(TUNIF_DEBUG, ("tunif_input: low_level_input returned NULL\n"));
+     return;
+   }
+ 
+   if(ip_lookup(p->payload, netif)) {
+     netif->input(p, netif);
+   }
+ }
+ /*-----------------------------------------------------------------------------------*/
+ /*
+  * tunif_init():
+  *
+  * Should be called at the beginning of the program to set up the
+  * network interface. It calls the function low_level_init() to do the
+  * actual setup of the hardware.
+  *
+  */
+ /*-----------------------------------------------------------------------------------*/
+ void
+ tunif_init(struct netif *netif)
+ {
+   struct tunif *tunif;
+     
+   tunif = mem_malloc(sizeof(struct tunif));
+   netif->state = tunif;
+   netif->name[0] = IFNAME0;
+   netif->name[1] = IFNAME1;
+   netif->output = tunif_output;
+   
+   
+   low_level_init(netif);
+ }
+ /*-----------------------------------------------------------------------------------*/