vde-2/tuntap.c

   1 /* Copyright 2005 Renzo Davoli - VDE-2
   2  * --pidfile/-p and cleanup management by Mattia Belletti (C) 2004.
   3  * Licensed under the GPLv2
   4  */
   5
   6 #include <config.h>
   7 #include <stdio.h>
   8 #include <fcntl.h>
   9 #include <errno.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12 #include <syslog.h>
  13 #include <stdlib.h>
  14 #include <libgen.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <sys/ioctl.h>
  18 #include <net/if.h>
  19 #include <stdarg.h>
  20 #define _GNU_SOURCE
  21 #include <getopt.h>
  22
  23 #include <linux/if_tun.h>
  24
  25 #include <port.h>
  26 #include <switch.h>
  27 #include <consmgmt.h>
  28
  29
  30 #define MAXCMD 128
  31 #define MODULENAME "tuntap"
  32
  33 static struct swmodule swmi;
  34 static struct mod_support modfun;
  35 static unsigned int tap_type;
  36
  37 struct init_tap {
  38         char *tap_dev;
  39         struct init_tap *next;
  40 };
  41
  42 struct init_tap *hinit_tap=NULL;
  43
  44 static void send_tap(int fd, int ctl_fd, void *packet, int len, void *unused, int port)
  45 {
  46         int n;
  47
  48         n = write(ctl_fd, packet, len);
  49         if(n != len){
  50                 if(errno != EAGAIN) printlog(LOG_WARNING,"send_tap port %d: %s",port,strerror(errno));
  51         }
  52 }
  53
  54 static void closeport(int fd, int portno)
  55 {
  56           if (fd>0)
  57                             remove_fd(fd);
  58 }
  59
  60 static void handle_input(unsigned char type,int fd,int revents,int *arg)
  61 {
  62         struct bipacket packet;
  63         int len=read(fd, &(packet.p), sizeof(struct packet));
  64
  65         if(len < 0){
  66                 if(errno != EAGAIN) printlog(LOG_WARNING,"Reading tap data: %s",strerror(errno));
  67         }
  68         else if(len == 0) {
  69                 if(errno != EAGAIN) printlog(LOG_WARNING,"EOF tap data port: %s",strerror(errno));
  70                 /* close tap! */
  71         } else if (len >= ETH_HEADER_SIZE)
  72                 handle_in_packet(*arg, &(packet.p), len);
  73 }
  74
  75
  76 static void cleanup(unsigned char type,int fd,int arg)
  77 {
  78         if (fd >= 0)
  79                 close(fd);
  80 }
  81
  82 static struct option long_options[] = {
  83         {"tap", 1, 0, 't'},
  84 };
  85 #define Nlong_options (sizeof(long_options)/sizeof(struct option));
  86
  87 static void usage(void)
  88 {
  89         printf(
  90                         "(opts from tuntap module)\n"
  91                         "  -t, --tap TAP              Enable routing through TAP tap interface\n"
  92                         );
  93 }
  94
  95 static struct init_tap *add_init_tap(struct init_tap *p,char *arg)
  96 {
  97         if (p == NULL) {
  98                 p=malloc(sizeof(struct init_tap));
  99                 if (p==NULL)
 100                         printlog(LOG_WARNING,"Malloc Tap init:%s\n",strerror(errno));
 101                 else {
 102                         p->tap_dev=strdup(optarg);
 103                         p->next=NULL;
 104                 }
 105         } else
 106                 p->next=add_init_tap(p->next,arg);
 107         return(p);
 108 }
 109
 110 static struct init_tap *free_init_tap(struct init_tap *p)
 111 {
 112         if (p != NULL) {
 113                 free_init_tap(p->next);
 114                 free(p);
 115         }
 116         return NULL;
 117 }
 118
 119 static int parseopt(int c, char *optarg)
 120 {
 121         int outc=0;
 122         switch (c) {
 123                 case 't':
 124                         hinit_tap=add_init_tap(hinit_tap,optarg);
 125                         break;
 126                 default:
 127                         outc=c;
 128         }
 129         return outc;
 130 }
 131
 132 int open_tap(char *dev)
 133 {
 134         struct ifreq ifr;
 135         int fd;
 136
 137         if((fd = open("/dev/net/tun", O_RDWR)) < 0){
 138                 printlog(LOG_ERR,"Failed to open /dev/net/tun %s",strerror(errno));
 139                 return(-1);
 140         }
 141         memset(&ifr, 0, sizeof(ifr));
 142         ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 143         strncpy(ifr.ifr_name, dev, sizeof(ifr.ifr_name) - 1);
 144         /*printf("dev=\"%s\", ifr.ifr_name=\"%s\"\n", ifr.ifr_name, dev);*/
 145         if(ioctl(fd, TUNSETIFF, (void *) &ifr) < 0){
 146                 printlog(LOG_ERR,"TUNSETIFF failed %s",strerror(errno));
 147                 close(fd);
 148                 return(-1);
 149         }
 150         return(fd);
 151 }
 152
 153 static int newport(int fd, int portno)
 154 {
 155         return fd;
 156 }
 157
 158 static int newtap(char *dev)
 159 {
 160         int tap_fd;
 161         tap_fd = open_tap(dev);
 162         if (tap_fd>0) {
 163                 int portno=setup_ep(0,tap_fd,NULL,&modfun);
 164                 if (portno >= 0) {
 165                         setup_description(portno,tap_fd,dev);
 166                         add_fd(tap_fd,tap_type,portno);
 167                         return portno;
 168                 } else
 169                         return -1;
 170         } else
 171                 return -1;
 172 }
 173
 174 static void init(void)
 175 {
 176         if(hinit_tap != NULL) {
 177                 struct init_tap *p;
 178                 tap_type=add_type(&swmi,1);
 179                 for(p=hinit_tap;p != NULL;p=p->next) {
 180                         if (newtap(p->tap_dev) < 0)
 181                                 printlog(LOG_ERR,"ERROR OPENING tap interface: %s",p->tap_dev);
 182                 }
 183                 hinit_tap=free_init_tap(hinit_tap);
 184         }
 185 }
 186
 187 static void delep (int fd, void* data, void *descr)
 188 {
 189         if (descr) free(descr);
 190 }
 191
 192 void start_tuntap(void)
 193 {
 194         modfun.modname=swmi.swmname=MODULENAME;
 195         swmi.swmnopts=Nlong_options;
 196         swmi.swmopts=long_options;
 197         swmi.usage=usage;
 198         swmi.parseopt=parseopt;
 199         swmi.init=init;
 200         swmi.handle_input=handle_input;
 201         swmi.cleanup=cleanup;
 202         modfun.sender=send_tap;
 203         modfun.newport=newport;
 204         modfun.delep=delep;
 205         modfun.delport=closeport;
 206         add_swm(&swmi);
 207 }