/*

 *  This file is part of DOS-libpcap

 *  Ported to DOS/DOSX by G. Vanem <gvanem@yahoo.no>

 *

 *  pcap-dos.c: Interface to PKTDRVR, NDIS2 and 32-bit pmode

 *              network drivers.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <float.h>

#include <fcntl.h>

#include <io.h>

#if defined(USE_32BIT_DRIVERS)

  #include "msdos/pm_drvr/pmdrvr.h"

  #include "msdos/pm_drvr/pci.h"

  #include "msdos/pm_drvr/bios32.h"

  #include "msdos/pm_drvr/module.h"

  #include "msdos/pm_drvr/3c501.h"

  #include "msdos/pm_drvr/3c503.h"

  #include "msdos/pm_drvr/3c509.h"

  #include "msdos/pm_drvr/3c59x.h"

  #include "msdos/pm_drvr/3c515.h"

  #include "msdos/pm_drvr/3c90x.h"

  #include "msdos/pm_drvr/3c575_cb.h"

  #include "msdos/pm_drvr/ne.h"

  #include "msdos/pm_drvr/wd.h"

  #include "msdos/pm_drvr/accton.h"

  #include "msdos/pm_drvr/cs89x0.h"

  #include "msdos/pm_drvr/rtl8139.h"

  #include "msdos/pm_drvr/ne2k-pci.h"

#endif

#include "pcap.h"

#include "pcap-dos.h"

#include "pcap-int.h"

#include "msdos/pktdrvr.h"

#ifdef USE_NDIS2

#include "msdos/ndis2.h"

#endif

#include <arpa/inet.h>

#include <net/if.h>

#include <net/if_arp.h>

#include <net/if_ether.h>

#include <net/if_packe.h>

#include <tcp.h>

#if defined(USE_32BIT_DRIVERS)

  #define FLUSHK()       do { _printk_safe = 1; _printk_flush(); } while (0)

  #define NDIS_NEXT_DEV  &rtl8139_dev

  static char *rx_pool = NULL;

  static void init_32bit (void);

  static int  pktq_init     (struct rx_ringbuf *q, int size, int num, char *pool);

  static int  pktq_check    (struct rx_ringbuf *q);

  static int  pktq_inc_out  (struct rx_ringbuf *q);

  static int  pktq_in_index (struct rx_ringbuf *q) LOCKED_FUNC;

  static void pktq_clear    (struct rx_ringbuf *q) LOCKED_FUNC;

  static struct rx_elem *pktq_in_elem  (struct rx_ringbuf *q) LOCKED_FUNC;

  static struct rx_elem *pktq_out_elem (struct rx_ringbuf *q);

#else

  #define FLUSHK()      ((void)0)

  #define NDIS_NEXT_DEV  NULL

#endif

/*

 * Internal variables/functions in Watt-32

 */

extern WORD  _pktdevclass;

extern BOOL  _eth_is_init;

extern int   _w32_dynamic_host;

extern int   _watt_do_exit;

extern int   _watt_is_init;

extern int   _w32__bootp_on, _w32__dhcp_on, _w32__rarp_on, _w32__do_mask_req;

extern void (*_w32_usr_post_init) (void);

extern void (*_w32_print_hook)();

extern void dbug_write (const char *);  /* Watt-32 lib, pcdbug.c */

extern int  pkt_get_mtu (void);

static int ref_count = 0;

static u_long mac_count    = 0;

static u_long filter_count = 0;

static volatile BOOL exc_occured = 0;

static struct device *handle_to_device [20];

static int  pcap_activate_dos (pcap_t *p);

static int  pcap_read_dos (pcap_t *p, int cnt, pcap_handler callback,

                           u_char *data);

static void pcap_cleanup_dos (pcap_t *p);

static int  pcap_stats_dos (pcap_t *p, struct pcap_stat *ps);

static int  pcap_sendpacket_dos (pcap_t *p, const void *buf, size_t len);

static int  pcap_setfilter_dos (pcap_t *p, struct bpf_program *fp);

static int  ndis_probe (struct device *dev);

static int  pkt_probe  (struct device *dev);

static void close_driver (void);

static int  init_watt32 (struct pcap *pcap, const char *dev_name, char *err_buf);

static int  first_init (const char *name, char *ebuf, int promisc);

static void watt32_recv_hook (u_char *dummy, const struct pcap_pkthdr *pcap,

                              const u_char *buf);

/*

 * These are the device we always support

 */

static struct device ndis_dev = {

              "ndis",

              "NDIS2 LanManager",

              0,

              0,0,0,0,0,0,

              NDIS_NEXT_DEV,  /* NULL or a 32-bit device */

              ndis_probe

            };

static struct device pkt_dev = {

              "pkt",

              "Packet-Driver",

              0,

              0,0,0,0,0,0,

              &ndis_dev,

              pkt_probe

            };

static struct device *get_device (int fd)

{

  if (fd <= 0 || fd >= sizeof(handle_to_device)/sizeof(handle_to_device[0]))

     return (NULL);

  return handle_to_device [fd-1];

}

/*

 * Private data for capturing on MS-DOS.

 */

struct pcap_dos {

	void (*wait_proc)(void); /* call proc while waiting */

	struct pcap_stat stat;

};

pcap_t *pcap_create_interface (const char *device _U_, char *ebuf)

{

	pcap_t *p;

	p = pcap_create_common(ebuf, sizeof (struct pcap_dos));

	if (p == NULL)

		return (NULL);

	p->activate_op = pcap_activate_dos;

	return (p);

}

/*

 * Open MAC-driver with name 'device_name' for live capture of

 * network packets.

 */

static int pcap_activate_dos (pcap_t *pcap)

{

  if (pcap->opt.rfmon) {

    /*

     * No monitor mode on DOS.

     */

    return (PCAP_ERROR_RFMON_NOTSUP);

  }

  /*

   * Turn a negative snapshot value (invalid), a snapshot value of

   * 0 (unspecified), or a value bigger than the normal maximum

   * value, into the maximum allowed value.

   *

   * If some application really *needs* a bigger snapshot

   * length, we should just increase MAXIMUM_SNAPLEN.

   */

  if (pcap->snapshot <= 0 || pcap->snapshot > MAXIMUM_SNAPLEN)

    pcap->snapshot = MAXIMUM_SNAPLEN;

  if (pcap->snapshot < ETH_MIN+8)

      pcap->snapshot = ETH_MIN+8;

  if (pcap->snapshot > ETH_MAX)   /* silently accept and truncate large MTUs */

      pcap->snapshot = ETH_MAX;

  pcap->linktype          = DLT_EN10MB;  /* !! */

  pcap->cleanup_op        = pcap_cleanup_dos;

  pcap->read_op           = pcap_read_dos;

  pcap->stats_op          = pcap_stats_dos;

  pcap->inject_op         = pcap_sendpacket_dos;

  pcap->setfilter_op      = pcap_setfilter_dos;

  pcap->setdirection_op   = NULL;  /* Not implemented.*/

  pcap->fd                = ++ref_count;

  pcap->bufsize = ETH_MAX+100;     /* add some margin */

  pcap->buffer = calloc (pcap->bufsize, 1);

  if (pcap->fd == 1)  /* first time we're called */

  {

    if (!init_watt32(pcap, pcap->opt.device, pcap->errbuf) ||

        !first_init(pcap->opt.device, pcap->errbuf, pcap->opt.promisc))

    {

      /* XXX - free pcap->buffer? */

      return (PCAP_ERROR);

    }

    atexit (close_driver);

  }

  else if (stricmp(active_dev->name,pcap->opt.device))

  {

    pcap_snprintf (pcap->errbuf, PCAP_ERRBUF_SIZE,

                   "Cannot use different devices simultaneously "

                   "(`%s' vs. `%s')", active_dev->name, pcap->opt.device);

    /* XXX - free pcap->buffer? */

    return (PCAP_ERROR);

  }

  handle_to_device [pcap->fd-1] = active_dev;

  return (0);

}

/*

 * Poll the receiver queue and call the pcap callback-handler

 * with the packet.

 */

static int

pcap_read_one (pcap_t *p, pcap_handler callback, u_char *data)

{

  struct pcap_dos *pd = p->priv;

  struct pcap_pkthdr pcap;

  struct timeval     now, expiry = { 0,0 };

  int    rx_len = 0;

  if (p->opt.timeout > 0)

  {

    gettimeofday2 (&now, NULL);

    expiry.tv_usec = now.tv_usec + 1000UL * p->opt.timeout;

    expiry.tv_sec  = now.tv_sec;

    while (expiry.tv_usec >= 1000000L)

    {

      expiry.tv_usec -= 1000000L;

      expiry.tv_sec++;

    }

  }

  while (!exc_occured)

  {

    volatile struct device *dev; /* might be reset by sig_handler */

    dev = get_device (p->fd);

    if (!dev)

       break;

    PCAP_ASSERT (dev->copy_rx_buf || dev->peek_rx_buf);

    FLUSHK();

    /* If driver has a zero-copy receive facility, peek at the queue,

     * filter it, do the callback and release the buffer.

     */

    if (dev->peek_rx_buf)

    {

      PCAP_ASSERT (dev->release_rx_buf);

      rx_len = (*dev->peek_rx_buf) (&p->buffer);

    }

    else

    {

      rx_len = (*dev->copy_rx_buf) (p->buffer, p->snapshot);

    }

    if (rx_len > 0)  /* got a packet */

    {

      mac_count++;

      FLUSHK();

      pcap.caplen = min (rx_len, p->snapshot);

      pcap.len    = rx_len;

      if (callback &&

          (!p->fcode.bf_insns || bpf_filter(p->fcode.bf_insns, p->buffer, pcap.len, pcap.caplen)))

      {

        filter_count++;

        /* Fix-me!! Should be time of arrival. Not time of

         * capture.

         */

        gettimeofday2 (&pcap.ts, NULL);

        (*callback) (data, &pcap, p->buffer);

      }

      if (dev->release_rx_buf)

        (*dev->release_rx_buf) (p->buffer);

      if (pcap_pkt_debug > 0)

      {

        if (callback == watt32_recv_hook)

             dbug_write ("pcap_recv_hook\n");

        else dbug_write ("pcap_read_op\n");

      }

      FLUSHK();

      return (1);

    }

    /* Has "pcap_breakloop()" been called?

     */

    if (p->break_loop) {

      /*

       * Yes - clear the flag that indicates that it

       * has, and return -2 to indicate that we were

       * told to break out of the loop.

       */

      p->break_loop = 0;

      return (-2);

    }

    /* If not to wait for a packet or pcap_cleanup_dos() called from

     * e.g. SIGINT handler, exit loop now.

     */

    if (p->opt.timeout <= 0 || (volatile int)p->fd <= 0)

       break;

    gettimeofday2 (&now, NULL);

    if (timercmp(&now, &expiry, >))

       break;

#ifndef DJGPP

    kbhit();    /* a real CPU hog */

#endif

    if (pd->wait_proc)

      (*pd->wait_proc)();     /* call yield func */

  }

  if (rx_len < 0)            /* receive error */

  {

    pd->stat.ps_drop++;

#ifdef USE_32BIT_DRIVERS

    if (pcap_pkt_debug > 1)

       printk ("pkt-err %s\n", pktInfo.error);

#endif

    return (-1);

  }

  return (0);

}

static int

pcap_read_dos (pcap_t *p, int cnt, pcap_handler callback, u_char *data)

{

  int rc, num = 0;

  while (num <= cnt || PACKET_COUNT_IS_UNLIMITED(cnt))

  {

    if (p->fd <= 0)

       return (-1);

    rc = pcap_read_one (p, callback, data);

    if (rc > 0)

       num++;

    if (rc < 0)

       break;

    _w32_os_yield();  /* allow SIGINT generation, yield to Win95/NT */

  }

  return (num);

}

/*

 * Return network statistics

 */

static int pcap_stats_dos (pcap_t *p, struct pcap_stat *ps)

{

  struct net_device_stats *stats;

  struct pcap_dos         *pd;

  struct device           *dev = p ? get_device(p->fd) : NULL;

  if (!dev)

  {

    strcpy (p->errbuf, "illegal pcap handle");

    return (-1);

  }

  if (!dev->get_stats || (stats = (*dev->get_stats)(dev)) == NULL)

  {

    strcpy (p->errbuf, "device statistics not available");

    return (-1);

  }

  FLUSHK();

  pd = p->priv;

  pd->stat.ps_recv   = stats->rx_packets;

  pd->stat.ps_drop  += stats->rx_missed_errors;

  pd->stat.ps_ifdrop = stats->rx_dropped +  /* queue full */

                         stats->rx_errors;    /* HW errors */

  if (ps)

     *ps = pd->stat;

  return (0);

}

/*

 * Return detailed network/device statistics.

 * May be called after 'dev->close' is called.

 */

int pcap_stats_ex (pcap_t *p, struct pcap_stat_ex *se)

{

  struct device *dev = p ? get_device (p->fd) : NULL;

  if (!dev || !dev->get_stats)

  {

    pcap_strlcpy (p->errbuf, "detailed device statistics not available",

             PCAP_ERRBUF_SIZE);

    return (-1);

  }

  if (!strnicmp(dev->name,"pkt",3))

  {

    pcap_strlcpy (p->errbuf, "pktdrvr doesn't have detailed statistics",

             PCAP_ERRBUF_SIZE);

    return (-1);

  }

  memcpy (se, (*dev->get_stats)(dev), sizeof(*se));

  return (0);

}

/*

 * Simply store the filter-code for the pcap_read_dos() callback

 * Some day the filter-code could be handed down to the active

 * device (pkt_rx1.s or 32-bit device interrupt handler).

 */

static int pcap_setfilter_dos (pcap_t *p, struct bpf_program *fp)

{

  if (!p)

     return (-1);

  p->fcode = *fp;

  return (0);

}

/*

 * Return # of packets received in pcap_read_dos()

 */

u_long pcap_mac_packets (void)

{

  return (mac_count);

}

/*

 * Return # of packets passed through filter in pcap_read_dos()

 */

u_long pcap_filter_packets (void)

{

  return (filter_count);

}

/*

 * Close pcap device. Not called for offline captures.

 */

static void pcap_cleanup_dos (pcap_t *p)

{

  struct pcap_dos *pd;

  if (!exc_occured)

  {

    pd = p->priv;

    if (pcap_stats(p,NULL) < 0)

       pd->stat.ps_drop = 0;

    if (!get_device(p->fd))

       return;

    handle_to_device [p->fd-1] = NULL;

    p->fd = 0;

    if (ref_count > 0)

        ref_count--;

    if (ref_count > 0)

       return;

  }

  close_driver();

  /* XXX - call pcap_cleanup_live_common? */

}

/*

 * Return the name of the 1st network interface,

 * or NULL if none can be found.

 */

char *pcap_lookupdev (char *ebuf)

{

  struct device *dev;

#ifdef USE_32BIT_DRIVERS

  init_32bit();

#endif

  for (dev = (struct device*)dev_base; dev; dev = dev->next)

  {

    PCAP_ASSERT (dev->probe);

    if ((*dev->probe)(dev))

    {

      FLUSHK();

      probed_dev = (struct device*) dev; /* remember last probed device */

      return (char*) dev->name;

    }

  }

  if (ebuf)

     strcpy (ebuf, "No driver found");

  return (NULL);

}

/*

 * Gets localnet & netmask from Watt-32.

 */

int pcap_lookupnet (const char *device, bpf_u_int32 *localnet,

                    bpf_u_int32 *netmask, char *errbuf)

{

  DWORD mask, net;

  if (!_watt_is_init)

  {

    strcpy (errbuf, "pcap_open_offline() or pcap_activate() must be "

                    "called first");

    return (-1);

  }

  mask  = _w32_sin_mask;

  net = my_ip_addr & mask;

  if (net == 0)

  {

    if (IN_CLASSA(*netmask))

       net = IN_CLASSA_NET;

    else if (IN_CLASSB(*netmask))

       net = IN_CLASSB_NET;

    else if (IN_CLASSC(*netmask))

       net = IN_CLASSC_NET;

    else

    {

      pcap_snprintf (errbuf, PCAP_ERRBUF_SIZE, "inet class for 0x%lx unknown", mask);

      return (-1);

    }

  }

  *localnet = htonl (net);

  *netmask = htonl (mask);

  ARGSUSED (device);

  return (0);

}

/*

 * Get a list of all interfaces that are present and that we probe okay.

 * Returns -1 on error, 0 otherwise.

 * The list may be NULL epty if no interfaces were up and could be opened.

 */

int pcap_platform_finddevs  (pcap_if_list_t *devlistp, char *errbuf)

{

  struct device     *dev;

  pcap_if_t *curdev;

#if 0   /* Pkt drivers should have no addresses */

  struct sockaddr_in sa_ll_1, sa_ll_2;

  struct sockaddr   *addr, *netmask, *broadaddr, *dstaddr;

#endif

  int       ret = 0;

  int       found = 0;

  for (dev = (struct device*)dev_base; dev; dev = dev->next)

  {

    PCAP_ASSERT (dev->probe);

    if (!(*dev->probe)(dev))

       continue;

    PCAP_ASSERT (dev->close);  /* set by probe routine */

    FLUSHK();

    (*dev->close) (dev);

    /*

     * XXX - find out whether it's up or running?  Does that apply here?

     * Can we find out if anything's plugged into the adapter, if it's

     * a wired device, and set PCAP_IF_CONNECTION_STATUS_CONNECTED

     * or PCAP_IF_CONNECTION_STATUS_DISCONNECTED?

     */

    if ((curdev = add_dev(devlistp, dev->name, 0,

                dev->long_name, errbuf)) == NULL)

    {

      ret = -1;

      break;

    }

    found = 1;

#if 0   /* Pkt drivers should have no addresses */

    memset (&sa_ll_1, 0, sizeof(sa_ll_1));

    memset (&sa_ll_2, 0, sizeof(sa_ll_2));

    sa_ll_1.sin_family = AF_INET;

    sa_ll_2.sin_family = AF_INET;

    addr      = (struct sockaddr*) &sa_ll_1;

    netmask   = (struct sockaddr*) &sa_ll_1;

    dstaddr   = (struct sockaddr*) &sa_ll_1;

    broadaddr = (struct sockaddr*) &sa_ll_2;

    memset (&sa_ll_2.sin_addr, 0xFF, sizeof(sa_ll_2.sin_addr));

    if (add_addr_to_dev(curdev, addr, sizeof(*addr),

                        netmask, sizeof(*netmask),

                        broadaddr, sizeof(*broadaddr),

                        dstaddr, sizeof(*dstaddr), errbuf) < 0)

    {

      ret = -1;

      break;

    }

#endif

  }

  if (ret == 0 && !found)

     strcpy (errbuf, "No drivers found");

  return (ret);

}

/*

 * pcap_assert() is mainly used for debugging

 */

void pcap_assert (const char *what, const char *file, unsigned line)

{

  FLUSHK();

  fprintf (stderr, "%s (%u): Assertion \"%s\" failed\n",

           file, line, what);

  close_driver();

  _exit (-1);

}

/*

 * For pcap_offline_read(): wait and yield between printing packets

 * to simulate the pace packets where actually recorded.

 */

void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait)

{

  if (p)

  {

    struct pcap_dos *pd = p->priv;

    pd->wait_proc  = yield;

    p->opt.timeout = wait;

  }

}

/*

 * Initialise a named network device.

 */

static struct device *

open_driver (const char *dev_name, char *ebuf, int promisc)

{

  struct device *dev;

  for (dev = (struct device*)dev_base; dev; dev = dev->next)

  {

    PCAP_ASSERT (dev->name);

    if (strcmp (dev_name,dev->name))

       continue;

    if (!probed_dev)   /* user didn't call pcap_lookupdev() first */

    {

      PCAP_ASSERT (dev->probe);

      if (!(*dev->probe)(dev))    /* call the xx_probe() function */

      {

        pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "failed to detect device `%s'", dev_name);

        return (NULL);

      }

      probed_dev = dev;  /* device is probed okay and may be used */

    }

    else if (dev != probed_dev)

    {

      goto not_probed;

    }

    FLUSHK();

    /* Select what traffic to receive

     */

    if (promisc)

         dev->flags |=  (IFF_ALLMULTI | IFF_PROMISC);

    else dev->flags &= ~(IFF_ALLMULTI | IFF_PROMISC);

    PCAP_ASSERT (dev->open);

    if (!(*dev->open)(dev))

    {

      pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "failed to activate device `%s'", dev_name);

      if (pktInfo.error && !strncmp(dev->name,"pkt",3))

      {

        strcat (ebuf, ": ");

        strcat (ebuf, pktInfo.error);

      }

      return (NULL);

    }

    /* Some devices need this to operate in promiscous mode

     */

    if (promisc && dev->set_multicast_list)

       (*dev->set_multicast_list) (dev);

    active_dev = dev;   /* remember our active device */

    break;

  }

  /* 'dev_name' not matched in 'dev_base' list.

   */

  if (!dev)

  {

    pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "device `%s' not supported", dev_name);

    return (NULL);

  }

not_probed:

  if (!probed_dev)

  {

    pcap_snprintf (ebuf, PCAP_ERRBUF_SIZE, "device `%s' not probed", dev_name);

    return (NULL);

  }

  return (dev);

}

/*

 * Deinitialise MAC driver.

 * Set receive mode back to default mode.

 */

static void close_driver (void)

{

  /* !!todo: loop over all 'handle_to_device[]' ? */

  struct device *dev = active_dev;

  if (dev && dev->close)

  {

    (*dev->close) (dev);

    FLUSHK();

  }

  active_dev = NULL;

#ifdef USE_32BIT_DRIVERS

  if (rx_pool)

  {

    k_free (rx_pool);

    rx_pool = NULL;

  }

  if (dev)

     pcibios_exit();

#endif

}

#ifdef __DJGPP__

static void setup_signals (void (*handler)(int))

{

  signal (SIGSEGV,handler);

  signal (SIGILL, handler);

  signal (SIGFPE, handler);

}

static void exc_handler (int sig)

{

#ifdef USE_32BIT_DRIVERS

  if (active_dev->irq > 0)    /* excludes IRQ 0 */

  {

    disable_irq (active_dev->irq);

    irq_eoi_cmd (active_dev->irq);

    _printk_safe = 1;

  }

#endif

  switch (sig)

  {

    case SIGSEGV:

         fputs ("Catching SIGSEGV.\n", stderr);

         break;

    case SIGILL:

         fputs ("Catching SIGILL.\n", stderr);

         break;

    case SIGFPE:

         _fpreset();

         fputs ("Catching SIGFPE.\n", stderr);

         break;

    default:

         fprintf (stderr, "Catching signal %d.\n", sig);

  }

  exc_occured = 1;

  close_driver();

}

#endif  /* __DJGPP__ */

/*

 * Open the pcap device for the first client calling pcap_activate()

 */

static int first_init (const char *name, char *ebuf, int promisc)

{

  struct device *dev;

#ifdef USE_32BIT_DRIVERS

  rx_pool = k_calloc (RECEIVE_BUF_SIZE, RECEIVE_QUEUE_SIZE);

  if (!rx_pool)

  {

    strcpy (ebuf, "Not enough memory (Rx pool)");

    return (0);

  }

#endif

#ifdef __DJGPP__

  setup_signals (exc_handler);

#endif

#ifdef USE_32BIT_DRIVERS

  init_32bit();

#endif

  dev = open_driver (name, ebuf, promisc);

  if (!dev)

  {

#ifdef USE_32BIT_DRIVERS

    k_free (rx_pool);

    rx_pool = NULL;

#endif

#ifdef __DJGPP__

    setup_signals (SIG_DFL);

#endif

    return (0);

  }

#ifdef USE_32BIT_DRIVERS

  /*

   * If driver is NOT a 16-bit "pkt/ndis" driver (having a 'copy_rx_buf'

   * set in it's probe handler), initialise near-memory ring-buffer for

   * the 32-bit device.

   */

  if (dev->copy_rx_buf == NULL)

  {

    dev->get_rx_buf     = get_rxbuf;

    dev->peek_rx_buf    = peek_rxbuf;

    dev->release_rx_buf = release_rxbuf;

    pktq_init (&dev->queue, RECEIVE_BUF_SIZE, RECEIVE_QUEUE_SIZE, rx_pool);

  }

#endif

  return (1);

}

#ifdef USE_32BIT_DRIVERS

static void init_32bit (void)

{

  static int init_pci = 0;

  if (!_printk_file)

     _printk_init (64*1024, NULL); /* calls atexit(printk_exit) */

  if (!init_pci)

     (void)pci_init();             /* init BIOS32+PCI interface */

  init_pci = 1;

}

#endif

/*

 * Hook functions for using Watt-32 together with pcap

 */

static char rxbuf [ETH_MAX+100]; /* rx-buffer with some margin */

static WORD etype;

static pcap_t pcap_save;

static void watt32_recv_hook (u_char *dummy, const struct pcap_pkthdr *pcap,

                              const u_char *buf)

{

  /* Fix me: assumes Ethernet II only */

  struct ether_header *ep = (struct ether_header*) buf;

  memcpy (rxbuf, buf, pcap->caplen);

  etype = ep->ether_type;