iodev/eth_vde.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: eth_vde.cc,v 1.15 2008/02/15 22:05:42 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2003  Renzo Davoli
   6 //
   7 //  This library is free software; you can redistribute it and/or
   8 //  modify it under the terms of the GNU Lesser General Public
   9 //  License as published by the Free Software Foundation; either
  10 //  version 2 of the License, or (at your option) any later version.
  11 //
  12 //  This library is distributed in the hope that it will be useful,
  13 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 //  Lesser General Public License for more details.
  16 //
  17 //  You should have received a copy of the GNU Lesser General Public
  18 //  License along with this library; if not, write to the Free Software
  19 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 //
  21 /////////////////////////////////////////////////////////////////////////
  22
  23 // eth_vde.cc  - Virtual Distributed Ethernet interface by Renzo Davoli <renzo@cs.unibo.it>
  24 //
  25
  26 // Define BX_PLUGGABLE in files that can be compiled into plugins.  For
  27 // platforms that require a special tag on exported symbols, BX_PLUGGABLE
  28 // is used to know when we are exporting symbols and when we are importing.
  29 #define BX_PLUGGABLE
  30
  31 #define NO_DEVICE_INCLUDES
  32 #include "iodev.h"
  33
  34 #if BX_NETWORKING && defined(HAVE_VDE)
  35
  36 #include "eth.h"
  37
  38 #define LOG_THIS bx_devices.pluginNE2kDevice->
  39
  40 #include <signal.h>
  41 #include <sys/param.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/poll.h>
  44 #include <sys/time.h>
  45 #include <sys/resource.h>
  46 #include <sys/socket.h>
  47 #if defined(__linux__)
  48 #include <asm/types.h>
  49 #include <linux/netlink.h>
  50 #include <linux/if.h>
  51 #elif BX_HAVE_NET_IF_H
  52 #include <net/if.h>
  53 #endif
  54 #include <sys/uio.h>
  55 #include <sys/wait.h>
  56 #include <sys/un.h>
  57 #include <assert.h>
  58 #include <fcntl.h>
  59 #include <errno.h>
  60 #include <unistd.h>
  61 #include <inttypes.h>
  62
  63 #define SWITCH_MAGIC 0xfeedface
  64
  65 #define BX_ETH_VDE_LOGGING 0
  66
  67 int vde_alloc(char *dev,int *fdp,struct sockaddr_un *pdataout);
  68
  69 //
  70 //  Define the class. This is private to this module
  71 //
  72 class bx_vde_pktmover_c : public eth_pktmover_c {
  73 public:
  74   bx_vde_pktmover_c(const char *netif, const char *macaddr,
  75                      eth_rx_handler_t rxh,
  76                      void *rxarg, char *script);
  77   void sendpkt(void *buf, unsigned io_len);
  78 private:
  79   int fd;
  80   int rx_timer_index;
  81   static void rx_timer_handler(void *);
  82   void rx_timer ();
  83   FILE *txlog, *txlog_txt, *rxlog, *rxlog_txt;
  84   int fddata;
  85   struct sockaddr_un dataout;
  86 };
  87
  88
  89 //
  90 //  Define the static class that registers the derived pktmover class,
  91 // and allocates one on request.
  92 //
  93 class bx_vde_locator_c : public eth_locator_c {
  94 public:
  95   bx_vde_locator_c(void) : eth_locator_c("vde") {}
  96 protected:
  97   eth_pktmover_c *allocate(const char *netif, const char *macaddr,
  98                            eth_rx_handler_t rxh,
  99                            void *rxarg, char *script) {
 100     return (new bx_vde_pktmover_c(netif, macaddr, rxh, rxarg, script));
 101   }
 102 } bx_vde_match;
 103
 104
 105 //
 106 // Define the methods for the bx_vde_pktmover derived class
 107 //
 108
 109 // the constructor
 110 bx_vde_pktmover_c::bx_vde_pktmover_c(const char *netif,
 111                                        const char *macaddr,
 112                                        eth_rx_handler_t rxh,
 113                                        void *rxarg,
 114                                        char *script)
 115 {
 116   int flags;
 117   //if (strncmp (netif, "vde", 3) != 0) {
 118    // BX_PANIC (("eth_vde: interface name (%s) must be vde", netif));
 119   //}
 120   char intname[IFNAMSIZ];
 121   if (netif == NULL || strcmp(netif,"") == 0)
 122           strcpy(intname,"/tmp/vde.ctl");
 123   else
 124         strcpy(intname,netif);
 125   fd=vde_alloc(intname,&fddata,&dataout);
 126   if (fd < 0) {
 127     BX_PANIC (("open failed on %s: %s", netif, strerror (errno)));
 128     return;
 129   }
 130
 131   /* set O_ASYNC flag so that we can poll with read() */
 132   if ((flags = fcntl(fd, F_GETFL)) < 0) {
 133     BX_PANIC (("getflags on vde device: %s", strerror (errno)));
 134   }
 135   flags |= O_NONBLOCK;
 136   if (fcntl(fd, F_SETFL, flags) < 0) {
 137     BX_PANIC (("set vde device flags: %s", strerror (errno)));
 138   }
 139
 140   BX_INFO(("eth_vde: opened %s device", netif));
 141
 142   /* Execute the configuration script */
 143   if((script != NULL) && (strcmp(script, "") != 0) && (strcmp(script, "none") != 0))
 144   {
 145     if (execute_script(script, intname) < 0)
 146       BX_ERROR (("execute script '%s' on %s failed", script, intname));
 147   }
 148
 149   // Start the rx poll
 150   this->rx_timer_index =
 151     bx_pc_system.register_timer(this, this->rx_timer_handler, 1000,
 152                                 1, 1, "eth_vde"); // continuous, active
 153   this->rxh   = rxh;
 154   this->rxarg = rxarg;
 155 #if BX_ETH_VDE_LOGGING
 156   // eventually Bryce wants txlog to dump in pcap format so that
 157   // tcpdump -r FILE can read it and interpret packets.
 158   txlog = fopen ("ne2k-tx.log", "wb");
 159   if (!txlog) BX_PANIC (("open ne2k-tx.log failed"));
 160   txlog_txt = fopen ("ne2k-txdump.txt", "wb");
 161   if (!txlog_txt) BX_PANIC (("open ne2k-txdump.txt failed"));
 162   fprintf (txlog_txt, "vde packetmover readable log file\n");
 163   fprintf (txlog_txt, "net IF = %s\n", netif);
 164   fprintf (txlog_txt, "MAC address = ");
 165   for (int i=0; i<6; i++)
 166     fprintf (txlog_txt, "%02x%s", 0xff & macaddr[i], i<5?":" : "");
 167   fprintf (txlog_txt, "\n--\n");
 168   fflush (txlog_txt);
 169
 170   rxlog = fopen ("ne2k-rx.log", "wb");
 171   if (!rxlog) BX_PANIC (("open ne2k-rx.log failed"));
 172   rxlog_txt = fopen ("ne2k-rxdump.txt", "wb");
 173   if (!rxlog_txt) BX_PANIC (("open ne2k-rxdump.txt failed"));
 174   fprintf (rxlog_txt, "vde packetmover readable log file\n");
 175   fprintf (rxlog_txt, "net IF = %s\n", netif);
 176   fprintf (rxlog_txt, "MAC address = ");
 177   for (int i=0; i<6; i++)
 178     fprintf (rxlog_txt, "%02x%s", 0xff & macaddr[i], i<5?":" : "");
 179   fprintf (rxlog_txt, "\n--\n");
 180   fflush (rxlog_txt);
 181
 182 #endif
 183 }
 184
 185 void bx_vde_pktmover_c::sendpkt(void *buf, unsigned io_len)
 186 {
 187   unsigned int size;
 188   //size = write (fd, buf, io_len);
 189   //size=send(fd,buf,io_len,0);
 190   size=sendto(fddata,buf,io_len,0,(struct sockaddr *) &dataout, sizeof(struct sockaddr_un));
 191   if (size != io_len) {
 192     BX_PANIC (("write on vde device: %s", strerror (errno)));
 193   } else {
 194     BX_INFO (("wrote %d bytes on vde", io_len));
 195   }
 196 #if BX_ETH_VDE_LOGGING
 197   BX_DEBUG (("sendpkt length %u", io_len));
 198   // dump raw bytes to a file, eventually dump in pcap format so that
 199   // tcpdump -r FILE can interpret them for us.
 200   int n = fwrite (buf, io_len, 1, txlog);
 201   if (n != 1) BX_ERROR (("fwrite to txlog failed", io_len));
 202   // dump packet in hex into an ascii log file
 203   fprintf (txlog_txt, "NE2K transmitting a packet, length %u\n", io_len);
 204   Bit8u *charbuf = (Bit8u *)buf;
 205   for (n=0; n<io_len; n++) {
 206     if (((n % 16) == 0) && n>0)
 207       fprintf (txlog_txt, "\n");
 208     fprintf (txlog_txt, "%02x ", charbuf[n]);
 209   }
 210   fprintf (txlog_txt, "\n--\n");
 211   // flush log so that we see the packets as they arrive w/o buffering
 212   fflush (txlog);
 213   fflush (txlog_txt);
 214 #endif
 215 }
 216
 217 void bx_vde_pktmover_c::rx_timer_handler (void *this_ptr)
 218 {
 219   bx_vde_pktmover_c *class_ptr = (bx_vde_pktmover_c *) this_ptr;
 220   class_ptr->rx_timer();
 221 }
 222
 223 void bx_vde_pktmover_c::rx_timer ()
 224 {
 225   int nbytes;
 226   Bit8u buf[BX_PACKET_BUFSIZE];
 227   Bit8u *rxbuf;
 228   struct sockaddr_un datain;
 229   socklen_t datainsize;
 230
 231   if (fd<0) return;
 232   //nbytes = read (fd, buf, sizeof(buf));
 233   nbytes=recvfrom(fddata,buf,sizeof(buf),MSG_DONTWAIT|MSG_WAITALL,(struct sockaddr *) &datain, &datainsize);
 234
 235   rxbuf=buf;
 236
 237   if (nbytes>0)
 238     BX_INFO (("vde read returned %d bytes", nbytes));
 239   if (nbytes<0) {
 240     if (errno != EAGAIN)
 241       BX_ERROR (("vde read error: %s", strerror(errno)));
 242     return;
 243   }
 244 #if BX_ETH_VDE_LOGGING
 245   if (nbytes > 0) {
 246     BX_DEBUG (("receive packet length %u", nbytes));
 247     // dump raw bytes to a file, eventually dump in pcap format so that
 248     // tcpdump -r FILE can interpret them for us.
 249     int n = fwrite (rxbuf, nbytes, 1, rxlog);
 250     if (n != 1) BX_ERROR (("fwrite to rxlog failed", nbytes));
 251     // dump packet in hex into an ascii log file
 252     fprintf (rxlog_txt, "NE2K received a packet, length %u\n", nbytes);
 253     for (n=0; n<nbytes; n++) {
 254       if (((n % 16) == 0) && n>0)
 255         fprintf (rxlog_txt, "\n");
 256       fprintf (rxlog_txt, "%02x ", rxbuf[n]);
 257     }
 258     fprintf (rxlog_txt, "\n--\n");
 259     // flush log so that we see the packets as they arrive w/o buffering
 260     fflush (rxlog);
 261     fflush (rxlog_txt);
 262   }
 263 #endif
 264   BX_DEBUG(("eth_vde: got packet: %d bytes, dst=%x:%x:%x:%x:%x:%x, src=%x:%x:%x:%x:%x:%x\n", nbytes, rxbuf[0], rxbuf[1], rxbuf[2], rxbuf[3], rxbuf[4], rxbuf[5], rxbuf[6], rxbuf[7], rxbuf[8], rxbuf[9], rxbuf[10], rxbuf[11]));
 265   if (nbytes < 60) {
 266     BX_INFO (("packet too short (%d), padding to 60", nbytes));
 267     nbytes = 60;
 268   }
 269   (*rxh)(rxarg, rxbuf, nbytes);
 270 }
 271
 272 //enum request_type { REQ_NEW_CONTROL };
 273 #define REQ_NEW_CONTROL 0
 274
 275 struct request_v3 {
 276   Bit32u magic;
 277   Bit32u version;
 278   //enum request_type type;
 279   int type;
 280   struct sockaddr_un sock;
 281 };
 282
 283 static int send_fd(char *name, int fddata, struct sockaddr_un *datasock, int group)
 284 {
 285   int pid = getpid();
 286   struct request_v3 req;
 287   int fdctl;
 288   struct sockaddr_un sock;
 289
 290   if((fdctl = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 291     perror("socket");
 292     return(-1);
 293   }
 294   sock.sun_family = AF_UNIX;
 295   snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);
 296   if(connect(fdctl, (struct sockaddr *) &sock, sizeof(sock))) {
 297     perror("connect");
 298     return(-1);
 299   }
 300
 301   req.magic=SWITCH_MAGIC;
 302   req.version=3;
 303   req.type=((int)REQ_NEW_CONTROL)+((group > 0)?((geteuid()<<8) + group) << 8:0);
 304   req.sock.sun_family=AF_UNIX;
 305   memset(req.sock.sun_path, 0, sizeof(req.sock.sun_path));
 306   sprintf(&req.sock.sun_path[1], "%5d", pid);
 307
 308   if(bind(fddata, (struct sockaddr *) &req.sock, sizeof(req.sock)) < 0) {
 309     perror("bind");
 310     return(-1);
 311   }
 312   if (send(fdctl,&req,sizeof(req),0) < 0) {
 313     perror("send");
 314     return(-1);
 315   }
 316   if (recv(fdctl,datasock,sizeof(struct sockaddr_un),0) < 0) {
 317     perror("recv");
 318     return(-1);
 319   }
 320   return fdctl;
 321 }
 322
 323 int vde_alloc(char *dev, int *fdp, struct sockaddr_un *pdataout)
 324 {
 325   //struct ifreq ifr;
 326   //int err;
 327   int fd, fddata;
 328
 329   if ((fddata = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
 330     return -1;
 331
 332   if ((fd = send_fd(dev, fddata, pdataout, 0)) < 0)
 333     return -1;
 334
 335   //memset(&ifr, 0, sizeof(ifr));
 336   *fdp=fddata;
 337
 338   return fd;
 339 }
 340
 341 #endif /* if BX_NETWORKING && defined HAVE_VDE */