external/bsd/libpcap/dist/pcap-dos.c

   1 /*      $NetBSD: pcap-dos.c,v 1.3 2015/03/31 21:39:42 christos Exp $    */
   2
   3 /*
   4  *  This file is part of DOS-libpcap
   5  *  Ported to DOS/DOSX by G. Vanem <gvanem@broadpark.no>
   6  *
   7  *  pcap-dos.c: Interface to PKTDRVR, NDIS2 and 32-bit pmode
   8  *              network drivers.
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <signal.h>
  15 #include <float.h>
  16 #include <fcntl.h>
  17 #include <io.h>
  18
  19 #if defined(USE_32BIT_DRIVERS)
  20   #include "msdos/pm_drvr/pmdrvr.h"
  21   #include "msdos/pm_drvr/pci.h"
  22   #include "msdos/pm_drvr/bios32.h"
  23   #include "msdos/pm_drvr/module.h"
  24   #include "msdos/pm_drvr/3c501.h"
  25   #include "msdos/pm_drvr/3c503.h"
  26   #include "msdos/pm_drvr/3c509.h"
  27   #include "msdos/pm_drvr/3c59x.h"
  28   #include "msdos/pm_drvr/3c515.h"
  29   #include "msdos/pm_drvr/3c90x.h"
  30   #include "msdos/pm_drvr/3c575_cb.h"
  31   #include "msdos/pm_drvr/ne.h"
  32   #include "msdos/pm_drvr/wd.h"
  33   #include "msdos/pm_drvr/accton.h"
  34   #include "msdos/pm_drvr/cs89x0.h"
  35   #include "msdos/pm_drvr/rtl8139.h"
  36   #include "msdos/pm_drvr/ne2k-pci.h"
  37 #endif
  38
  39 #include "pcap.h"
  40 #include "pcap-dos.h"
  41 #include "pcap-int.h"
  42 #include "msdos/pktdrvr.h"
  43
  44 #ifdef USE_NDIS2
  45 #include "msdos/ndis2.h"
  46 #endif
  47
  48 #include <arpa/inet.h>
  49 #include <net/if.h>
  50 #include <net/if_arp.h>
  51 #include <net/if_ether.h>
  52 #include <net/if_packe.h>
  53 #include <tcp.h>
  54
  55 #if defined(USE_32BIT_DRIVERS)
  56   #define FLUSHK()       do { _printk_safe = 1; _printk_flush(); } while (0)
  57   #define NDIS_NEXT_DEV  &rtl8139_dev
  58
  59   static char *rx_pool = NULL;
  60   static void init_32bit (void);
  61
  62   static int  pktq_init     (struct rx_ringbuf *q, int size, int num, char *pool);
  63   static int  pktq_check    (struct rx_ringbuf *q);
  64   static int  pktq_inc_out  (struct rx_ringbuf *q);
  65   static int  pktq_in_index (struct rx_ringbuf *q) LOCKED_FUNC;
  66   static void pktq_clear    (struct rx_ringbuf *q) LOCKED_FUNC;
  67
  68   static struct rx_elem *pktq_in_elem  (struct rx_ringbuf *q) LOCKED_FUNC;
  69   static struct rx_elem *pktq_out_elem (struct rx_ringbuf *q);
  70
  71 #else
  72   #define FLUSHK()      ((void)0)
  73   #define NDIS_NEXT_DEV  NULL
  74 #endif
  75
  76 /*
  77  * Internal variables/functions in Watt-32
  78  */
  79 extern WORD  _pktdevclass;
  80 extern BOOL  _eth_is_init;
  81 extern int   _w32_dynamic_host;
  82 extern int   _watt_do_exit;
  83 extern int   _watt_is_init;
  84 extern int   _w32__bootp_on, _w32__dhcp_on, _w32__rarp_on, _w32__do_mask_req;
  85 extern void (*_w32_usr_post_init) (void);
  86 extern void (*_w32_print_hook)();
  87
  88 extern void dbug_write (const char *);  /* Watt-32 lib, pcdbug.c */
  89 extern int  pkt_get_mtu (void);
  90
  91 static int ref_count = 0;
  92
  93 static u_long mac_count    = 0;
  94 static u_long filter_count = 0;
  95
  96 static volatile BOOL exc_occured = 0;
  97
  98 static struct device *handle_to_device [20];
  99
 100 static int  pcap_activate_dos (pcap_t *p);
 101 static int  pcap_read_dos (pcap_t *p, int cnt, pcap_handler callback,
 102                            u_char *data);
 103 static void pcap_cleanup_dos (pcap_t *p);
 104 static int  pcap_stats_dos (pcap_t *p, struct pcap_stat *ps);
 105 static int  pcap_sendpacket_dos (pcap_t *p, const void *buf, size_t len);
 106 static int  pcap_setfilter_dos (pcap_t *p, struct bpf_program *fp);
 107
 108 static int  ndis_probe (struct device *dev);
 109 static int  pkt_probe  (struct device *dev);
 110
 111 static void close_driver (void);
 112 static int  init_watt32 (struct pcap *pcap, const char *dev_name, char *err_buf);
 113 static int  first_init (const char *name, char *ebuf, int promisc);
 114
 115 static void watt32_recv_hook (u_char *dummy, const struct pcap_pkthdr *pcap,
 116                               const u_char *buf);
 117
 118 /*
 119  * These are the device we always support
 120  */
 121 static struct device ndis_dev = {
 122               "ndis",
 123               "NDIS2 LanManager",
 124               0,
 125               0,0,0,0,0,0,
 126               NDIS_NEXT_DEV,  /* NULL or a 32-bit device */
 127               ndis_probe
 128             };
 129
 130 static struct device pkt_dev = {
 131               "pkt",
 132               "Packet-Driver",
 133               0,
 134               0,0,0,0,0,0,
 135               &ndis_dev,
 136               pkt_probe
 137             };
 138
 139 static struct device *get_device (int fd)
 140 {
 141   if (fd <= 0 || fd >= sizeof(handle_to_device)/sizeof(handle_to_device[0]))
 142      return (NULL);
 143   return handle_to_device [fd-1];
 144 }
 145
 146 /*
 147  * Private data for capturing on MS-DOS.
 148  */
 149 struct pcap_dos {
 150         void (*wait_proc)(void); /*          call proc while waiting */
 151         struct pcap_stat stat;
 152 };
 153
 154 pcap_t *pcap_create_interface (const char *device, char *ebuf)
 155 {
 156         pcap_t *p;
 157
 158         p = pcap_create_common(device, ebuf, sizeof (struct pcap_dos));
 159         if (p == NULL)
 160                 return (NULL);
 161
 162         p->activate_op = pcap_activate_dos;
 163         return (p);
 164 }
 165
 166 /*
 167  * Open MAC-driver with name 'device_name' for live capture of
 168  * network packets.
 169  */
 170 static int pcap_activate_dos (pcap_t *pcap)
 171 {
 172   struct pcap_dos *pcapd = pcap->priv;
 173
 174   if (pcap->opt.rfmon) {
 175     /*
 176      * No monitor mode on DOS.
 177      */
 178     return (PCAP_ERROR_RFMON_NOTSUP);
 179   }
 180
 181   if (pcap->snapshot < ETH_MIN+8)
 182       pcap->snapshot = ETH_MIN+8;
 183
 184   if (pcap->snapshot > ETH_MAX)   /* silently accept and truncate large MTUs */
 185       pcap->snapshot = ETH_MAX;
 186
 187   pcap->linktype          = DLT_EN10MB;  /* !! */
 188   pcap->cleanup_op        = pcap_cleanup_dos;
 189   pcap->read_op           = pcap_read_dos;
 190   pcap->stats_op          = pcap_stats_dos;
 191   pcap->inject_op         = pcap_sendpacket_dos;
 192   pcap->setfilter_op      = pcap_setfilter_dos;
 193   pcap->setdirection_op   = NULL; /* Not implemented.*/
 194   pcap->fd                = ++ref_count;
 195
 196   if (pcap->fd == 1)  /* first time we're called */
 197   {
 198     if (!init_watt32(pcap, pcap->opt.source, pcap->errbuf) ||
 199         !first_init(pcap->opt.source, pcap->errbuf, pcap->opt.promisc))
 200     {
 201       return (PCAP_ERROR);
 202     }
 203     atexit (close_driver);
 204   }
 205   else if (stricmp(active_dev->name,pcap->opt.source))
 206   {
 207     snprintf (pcap->errbuf, PCAP_ERRBUF_SIZE,
 208               "Cannot use different devices simultaneously "
 209               "(`%s' vs. `%s')", active_dev->name, pcap->opt.source);
 210     return (PCAP_ERROR);
 211   }
 212   handle_to_device [pcap->fd-1] = active_dev;
 213   return (0);
 214 }
 215
 216 /*
 217  * Poll the receiver queue and call the pcap callback-handler
 218  * with the packet.
 219  */
 220 static int
 221 pcap_read_one (pcap_t *p, pcap_handler callback, u_char *data)
 222 {
 223   struct pcap_dos *pd = p->priv;
 224   struct pcap_pkthdr pcap;
 225   struct timeval     now, expiry = { 0,0 };
 226   BYTE  *rx_buf;
 227   int    rx_len = 0;
 228
 229   if (p->opt.timeout > 0)
 230   {
 231     gettimeofday2 (&now, NULL);
 232     expiry.tv_usec = now.tv_usec + 1000UL * p->opt.timeout;
 233     expiry.tv_sec  = now.tv_sec;
 234     while (expiry.tv_usec >= 1000000L)
 235     {
 236       expiry.tv_usec -= 1000000L;
 237       expiry.tv_sec++;
 238     }
 239   }
 240
 241   while (!exc_occured)
 242   {
 243     volatile struct device *dev; /* might be reset by sig_handler */
 244
 245     dev = get_device (p->fd);
 246     if (!dev)
 247        break;
 248
 249     PCAP_ASSERT (dev->copy_rx_buf || dev->peek_rx_buf);
 250     FLUSHK();
 251
 252     /* If driver has a zero-copy receive facility, peek at the queue,
 253      * filter it, do the callback and release the buffer.
 254      */
 255     if (dev->peek_rx_buf)
 256     {
 257       PCAP_ASSERT (dev->release_rx_buf);
 258       rx_len = (*dev->peek_rx_buf) (&rx_buf);
 259     }
 260     else
 261     {
 262       BYTE buf [ETH_MAX+100]; /* add some margin */
 263       rx_len = (*dev->copy_rx_buf) (buf, p->snapshot);
 264       rx_buf = buf;
 265     }
 266
 267     if (rx_len > 0)  /* got a packet */
 268     {
 269       mac_count++;
 270
 271       FLUSHK();
 272
 273       pcap.caplen = min (rx_len, p->snapshot);
 274       pcap.len    = rx_len;
 275
 276       if (callback &&
 277           (!p->fcode.bf_insns || bpf_filter(p->fcode.bf_insns, rx_buf, pcap.len, pcap.caplen)))
 278       {
 279         filter_count++;
 280
 281         /* Fix-me!! Should be time of arrival. Not time of
 282          * capture.
 283          */
 284         gettimeofday2 (&pcap.ts, NULL);
 285         (*callback) (data, &pcap, rx_buf);
 286       }
 287
 288       if (dev->release_rx_buf)
 289         (*dev->release_rx_buf) (rx_buf);
 290
 291       if (pcap_pkt_debug > 0)
 292       {
 293         if (callback == watt32_recv_hook)
 294              dbug_write ("pcap_recv_hook\n");
 295         else dbug_write ("pcap_read_op\n");
 296       }
 297       FLUSHK();
 298       return (1);
 299     }
 300
 301     /* If not to wait for a packet or pcap_cleanup_dos() called from
 302      * e.g. SIGINT handler, exit loop now.
 303      */
 304     if (p->opt.timeout <= 0 || (volatile int)p->fd <= 0)
 305        break;
 306
 307     gettimeofday2 (&now, NULL);
 308
 309     if (timercmp(&now, &expiry, >))
 310        break;
 311
 312 #ifndef DJGPP
 313     kbhit();    /* a real CPU hog */
 314 #endif
 315
 316     if (p->wait_proc)
 317       (*p->wait_proc)();     /* call yield func */
 318   }
 319
 320   if (rx_len < 0)            /* receive error */
 321   {
 322     pd->stat.ps_drop++;
 323 #ifdef USE_32BIT_DRIVERS
 324     if (pcap_pkt_debug > 1)
 325        printk ("pkt-err %s\n", pktInfo.error);
 326 #endif
 327     return (-1);
 328   }
 329   return (0);
 330 }
 331
 332 static int
 333 pcap_read_dos (pcap_t *p, int cnt, pcap_handler callback, u_char *data)
 334 {
 335   struct pcap_dos *pd = p->priv;
 336   int rc, num = 0;
 337
 338   while (num <= cnt || PACKET_COUNT_IS_UNLIMITED(cnt))
 339   {
 340     if (p->fd <= 0)
 341        return (-1);
 342     rc = pcap_read_one (p, callback, data);
 343     if (rc > 0)
 344        num++;
 345     if (rc < 0)
 346        break;
 347     _w32_os_yield();  /* allow SIGINT generation, yield to Win95/NT */
 348   }
 349   return (num);
 350 }
 351
 352 /*
 353  * Return network statistics
 354  */
 355 static int pcap_stats_dos (pcap_t *p, struct pcap_stat *ps)
 356 {
 357   struct net_device_stats *stats;
 358   struct pcap_dos         *pd;
 359   struct device           *dev = p ? get_device(p->fd) : NULL;
 360
 361   if (!dev)
 362   {
 363     strcpy (p->errbuf, "illegal pcap handle");
 364     return (-1);
 365   }
 366
 367   if (!dev->get_stats || (stats = (*dev->get_stats)(dev)) == NULL)
 368   {
 369     strcpy (p->errbuf, "device statistics not available");
 370     return (-1);
 371   }
 372
 373   FLUSHK();
 374
 375   pd = p->priv;
 376   pd->stat.ps_recv   = stats->rx_packets;
 377   pd->stat.ps_drop  += stats->rx_missed_errors;
 378   pd->stat.ps_ifdrop = stats->rx_dropped +  /* queue full */
 379                          stats->rx_errors;    /* HW errors */
 380   if (ps)
 381      *ps = pd->stat;
 382
 383   return (0);
 384 }
 385
 386 /*
 387  * Return detailed network/device statistics.
 388  * May be called after 'dev->close' is called.
 389  */
 390 int pcap_stats_ex (pcap_t *p, struct pcap_stat_ex *se)
 391 {
 392   struct device *dev = p ? get_device (p->fd) : NULL;
 393
 394   if (!dev || !dev->get_stats)
 395   {
 396     strlcpy (p->errbuf, "detailed device statistics not available",
 397              PCAP_ERRBUF_SIZE);
 398     return (-1);
 399   }
 400
 401   if (!strnicmp(dev->name,"pkt",3))
 402   {
 403     strlcpy (p->errbuf, "pktdrvr doesn't have detailed statistics",
 404              PCAP_ERRBUF_SIZE);
 405     return (-1);
 406   }
 407   memcpy (se, (*dev->get_stats)(dev), sizeof(*se));
 408   return (0);
 409 }
 410
 411 /*
 412  * Simply store the filter-code for the pcap_read_dos() callback
 413  * Some day the filter-code could be handed down to the active
 414  * device (pkt_rx1.s or 32-bit device interrupt handler).
 415  */
 416 static int pcap_setfilter_dos (pcap_t *p, struct bpf_program *fp)
 417 {
 418   if (!p)
 419      return (-1);
 420   p->fcode = *fp;
 421   return (0);
 422 }
 423
 424 /*
 425  * Return # of packets received in pcap_read_dos()
 426  */
 427 u_long pcap_mac_packets (void)
 428 {
 429   return (mac_count);
 430 }
 431
 432 /*
 433  * Return # of packets passed through filter in pcap_read_dos()
 434  */
 435 u_long pcap_filter_packets (void)
 436 {
 437   return (filter_count);
 438 }
 439
 440 /*
 441  * Close pcap device. Not called for offline captures.
 442  */
 443 static void pcap_cleanup_dos (pcap_t *p)
 444 {
 445   struct pcap_dos *pd;
 446
 447   if (p && !exc_occured)
 448   {
 449     pd = p->priv;
 450     if (pcap_stats(p,NULL) < 0)
 451        pd->stat.ps_drop = 0;
 452     if (!get_device(p->fd))
 453        return;
 454
 455     handle_to_device [p->fd-1] = NULL;
 456     p->fd = 0;
 457     if (ref_count > 0)
 458         ref_count--;
 459     if (ref_count > 0)
 460        return;
 461   }
 462   close_driver();
 463 }
 464
 465 /*
 466  * Return the name of the 1st network interface,
 467  * or NULL if none can be found.
 468  */
 469 char *pcap_lookupdev (char *ebuf)
 470 {
 471   struct device *dev;
 472
 473 #ifdef USE_32BIT_DRIVERS
 474   init_32bit();
 475 #endif
 476
 477   for (dev = (struct device*)dev_base; dev; dev = dev->next)
 478   {
 479     PCAP_ASSERT (dev->probe);
 480
 481     if ((*dev->probe)(dev))
 482     {
 483       FLUSHK();
 484       probed_dev = (struct device*) dev; /* remember last probed device */
 485       return (char*) dev->name;
 486     }
 487   }
 488
 489   if (ebuf)
 490      strcpy (ebuf, "No driver found");
 491   return (NULL);
 492 }
 493
 494 /*
 495  * Gets localnet & netmask from Watt-32.
 496  */
 497 int pcap_lookupnet (const char *device, bpf_u_int32 *localnet,
 498                     bpf_u_int32 *netmask, char *errbuf)
 499 {
 500   if (!_watt_is_init)
 501   {
 502     strcpy (errbuf, "pcap_open_offline() or pcap_activate() must be "
 503                     "called first");
 504     return (-1);
 505   }
 506
 507   *netmask  = _w32_sin_mask;
 508   *localnet = my_ip_addr & *netmask;
 509   if (*localnet == 0)
 510   {
 511     if (IN_CLASSA(*netmask))
 512        *localnet = IN_CLASSA_NET;
 513     else if (IN_CLASSB(*netmask))
 514        *localnet = IN_CLASSB_NET;
 515     else if (IN_CLASSC(*netmask))
 516        *localnet = IN_CLASSC_NET;
 517     else
 518     {
 519       sprintf (errbuf, "inet class for 0x%lx unknown", *netmask);
 520       return (-1);
 521     }
 522   }
 523   ARGSUSED (device);
 524   return (0);
 525 }
 526
 527 /*
 528  * Get a list of all interfaces that are present and that we probe okay.
 529  * Returns -1 on error, 0 otherwise.
 530  * The list, as returned through "alldevsp", may be null if no interfaces
 531  * were up and could be opened.
 532  */
 533 int pcap_findalldevs (pcap_if_t **alldevsp, char *errbuf)
 534 {
 535   struct device     *dev;
 536   struct sockaddr_ll sa_ll_1, sa_ll_2;
 537   struct sockaddr   *addr, *netmask, *broadaddr, *dstaddr;
 538   pcap_if_t *devlist = NULL;
 539   int       ret = 0;
 540   size_t    addr_size = sizeof(struct sockaddr_ll);
 541
 542   for (dev = (struct device*)dev_base; dev; dev = dev->next)
 543   {
 544     PCAP_ASSERT (dev->probe);
 545
 546     if (!(*dev->probe)(dev))
 547        continue;
 548
 549     PCAP_ASSERT (dev->close);  /* set by probe routine */
 550     FLUSHK();
 551     (*dev->close) (dev);
 552
 553     memset (&sa_ll_1, 0, sizeof(sa_ll_1));
 554     memset (&sa_ll_2, 0, sizeof(sa_ll_2));
 555     sa_ll_1.sll_family = AF_PACKET;
 556     sa_ll_2.sll_family = AF_PACKET;
 557
 558     addr      = (struct sockaddr*) &sa_ll_1;
 559     netmask   = (struct sockaddr*) &sa_ll_1;
 560     dstaddr   = (struct sockaddr*) &sa_ll_1;
 561     broadaddr = (struct sockaddr*) &sa_ll_2;
 562     memset (&sa_ll_2.sll_addr, 0xFF, sizeof(sa_ll_2.sll_addr));
 563
 564     if (pcap_add_if(&devlist, dev->name, dev->flags,
 565                     dev->long_name, errbuf) < 0)
 566     {
 567       ret = -1;
 568       break;
 569     }
 570     if (add_addr_to_iflist(&devlist,dev->name, dev->flags, addr, addr_size,
 571                            netmask, addr_size, broadaddr, addr_size,
 572                            dstaddr, addr_size, errbuf) < 0)
 573     {
 574       ret = -1;
 575       break;
 576     }
 577   }
 578
 579   if (devlist && ret < 0)
 580   {
 581     pcap_freealldevs (devlist);
 582     devlist = NULL;
 583   }
 584   else
 585   if (!devlist)
 586      strcpy (errbuf, "No drivers found");
 587
 588   *alldevsp = devlist;
 589   return (ret);
 590 }
 591
 592 /*
 593  * pcap_assert() is mainly used for debugging
 594  */
 595 void pcap_assert (const char *what, const char *file, unsigned line)
 596 {
 597   FLUSHK();
 598   fprintf (stderr, "%s (%u): Assertion \"%s\" failed\n",
 599            file, line, what);
 600   close_driver();
 601   _exit (-1);
 602 }
 603
 604 /*
 605  * For pcap_offline_read(): wait and yield between printing packets
 606  * to simulate the pace packets where actually recorded.
 607  */
 608 void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait)
 609 {
 610   struct pcap_dos *pd;
 611   if (p)
 612   {
 613     pd                   = p->priv;
 614     pd->wait_proc        = yield;
 615     p->opt.timeout        = wait;
 616   }
 617 }
 618
 619 /*
 620  * Initialise a named network device.
 621  */
 622 static struct device *
 623 open_driver (const char *dev_name, char *ebuf, int promisc)
 624 {
 625   struct device *dev;
 626
 627   for (dev = (struct device*)dev_base; dev; dev = dev->next)
 628   {
 629     PCAP_ASSERT (dev->name);
 630
 631     if (strcmp (dev_name,dev->name))
 632        continue;
 633
 634     if (!probed_dev)   /* user didn't call pcap_lookupdev() first */
 635     {
 636       PCAP_ASSERT (dev->probe);
 637
 638       if (!(*dev->probe)(dev))    /* call the xx_probe() function */
 639       {
 640         sprintf (ebuf, "failed to detect device `%s'", dev_name);
 641         return (NULL);
 642       }
 643       probed_dev = dev;  /* device is probed okay and may be used */
 644     }
 645     else if (dev != probed_dev)
 646     {
 647       goto not_probed;
 648     }
 649
 650     FLUSHK();
 651
 652     /* Select what traffic to receive
 653      */
 654     if (promisc)
 655          dev->flags |=  (IFF_ALLMULTI | IFF_PROMISC);
 656     else dev->flags &= ~(IFF_ALLMULTI | IFF_PROMISC);
 657
 658     PCAP_ASSERT (dev->open);
 659
 660     if (!(*dev->open)(dev))
 661     {
 662       sprintf (ebuf, "failed to activate device `%s'", dev_name);
 663       if (pktInfo.error && !strncmp(dev->name,"pkt",3))
 664       {
 665         strcat (ebuf, ": ");
 666         strcat (ebuf, pktInfo.error);
 667       }
 668       return (NULL);
 669     }
 670
 671     /* Some devices need this to operate in promiscous mode
 672      */
 673     if (promisc && dev->set_multicast_list)
 674        (*dev->set_multicast_list) (dev);
 675
 676     active_dev = dev;   /* remember our active device */
 677     break;
 678   }
 679
 680   /* 'dev_name' not matched in 'dev_base' list.
 681    */
 682   if (!dev)
 683   {
 684     sprintf (ebuf, "device `%s' not supported", dev_name);
 685     return (NULL);
 686   }
 687
 688 not_probed:
 689   if (!probed_dev)
 690   {
 691     sprintf (ebuf, "device `%s' not probed", dev_name);
 692     return (NULL);
 693   }
 694   return (dev);
 695 }
 696
 697 /*
 698  * Deinitialise MAC driver.
 699  * Set receive mode back to default mode.
 700  */
 701 static void close_driver (void)
 702 {
 703   /* !!todo: loop over all 'handle_to_device[]' ? */
 704   struct device *dev = active_dev;
 705
 706   if (dev && dev->close)
 707   {
 708     (*dev->close) (dev);
 709     FLUSHK();
 710   }
 711
 712   active_dev = NULL;
 713
 714 #ifdef USE_32BIT_DRIVERS
 715   if (rx_pool)
 716   {
 717     k_free (rx_pool);
 718     rx_pool = NULL;
 719   }
 720   if (dev)
 721      pcibios_exit();
 722 #endif
 723 }
 724
 725
 726 #ifdef __DJGPP__
 727 static void setup_signals (void (*handler)(int))
 728 {
 729   signal (SIGSEGV,handler);
 730   signal (SIGILL, handler);
 731   signal (SIGFPE, handler);
 732 }
 733
 734 static void exc_handler (int sig)
 735 {
 736 #ifdef USE_32BIT_DRIVERS
 737   if (active_dev->irq > 0)    /* excludes IRQ 0 */
 738   {
 739     disable_irq (active_dev->irq);
 740     irq_eoi_cmd (active_dev->irq);
 741     _printk_safe = 1;
 742   }
 743 #endif
 744
 745   switch (sig)
 746   {
 747     case SIGSEGV:
 748          fputs ("Catching SIGSEGV.\n", stderr);
 749          break;
 750     case SIGILL:
 751          fputs ("Catching SIGILL.\n", stderr);
 752          break;
 753     case SIGFPE:
 754          _fpreset();
 755          fputs ("Catching SIGFPE.\n", stderr);
 756          break;
 757     default:
 758          fprintf (stderr, "Catching signal %d.\n", sig);
 759   }
 760   exc_occured = 1;
 761   pcap_cleanup_dos (NULL);
 762 }
 763 #endif  /* __DJGPP__ */
 764
 765
 766 /*
 767  * Open the pcap device for the first client calling pcap_activate()
 768  */
 769 static int first_init (const char *name, char *ebuf, int promisc)
 770 {
 771   struct device *dev;
 772
 773 #ifdef USE_32BIT_DRIVERS
 774   rx_pool = k_calloc (RECEIVE_BUF_SIZE, RECEIVE_QUEUE_SIZE);
 775   if (!rx_pool)
 776   {
 777     strcpy (ebuf, "Not enough memory (Rx pool)");
 778     return (0);
 779   }
 780 #endif
 781
 782 #ifdef __DJGPP__
 783   setup_signals (exc_handler);
 784 #endif
 785
 786 #ifdef USE_32BIT_DRIVERS
 787   init_32bit();
 788 #endif
 789
 790   dev = open_driver (name, ebuf, promisc);
 791   if (!dev)
 792   {
 793 #ifdef USE_32BIT_DRIVERS
 794     k_free (rx_pool);
 795     rx_pool = NULL;
 796 #endif
 797
 798 #ifdef __DJGPP__
 799     setup_signals (SIG_DFL);
 800 #endif
 801     return (0);
 802   }
 803
 804 #ifdef USE_32BIT_DRIVERS
 805   /*
 806    * If driver is NOT a 16-bit "pkt/ndis" driver (having a 'copy_rx_buf'
 807    * set in it's probe handler), initialise near-memory ring-buffer for
 808    * the 32-bit device.
 809    */
 810   if (dev->copy_rx_buf == NULL)
 811   {
 812     dev->get_rx_buf     = get_rxbuf;
 813     dev->peek_rx_buf    = peek_rxbuf;
 814     dev->release_rx_buf = release_rxbuf;
 815     pktq_init (&dev->queue, RECEIVE_BUF_SIZE, RECEIVE_QUEUE_SIZE, rx_pool);
 816   }
 817 #endif
 818   return (1);
 819 }
 820
 821 #ifdef USE_32BIT_DRIVERS
 822 static void init_32bit (void)
 823 {
 824   static int init_pci = 0;
 825
 826   if (!_printk_file)
 827      _printk_init (64*1024, NULL); /* calls atexit(printk_exit) */
 828
 829   if (!init_pci)
 830      (void)pci_init();             /* init BIOS32+PCI interface */
 831   init_pci = 1;
 832 }
 833 #endif
 834
 835
 836 /*
 837  * Hook functions for using Watt-32 together with pcap
 838  */
 839 static char rxbuf [ETH_MAX+100]; /* rx-buffer with some margin */
 840 static WORD etype;
 841 static pcap_t pcap_save;
 842
 843 static void watt32_recv_hook (u_char *dummy, const struct pcap_pkthdr *pcap,
 844                               const u_char *buf)
 845 {
 846   /* Fix me: assumes Ethernet II only */
 847   struct ether_header *ep = (struct ether_header*) buf;
 848
 849   memcpy (rxbuf, buf, pcap->caplen);
 850   etype = ep->ether_type;
 851   ARGSUSED (dummy);
 852 }
 853
 854 #if (WATTCP_VER >= 0x0224)
 855 /*
 856  * This function is used by Watt-32 to poll for a packet.
 857  * i.e. it's set to bypass _eth_arrived()
 858  */
 859 static void *pcap_recv_hook (WORD *type)
 860 {
 861   int len = pcap_read_dos (&pcap_save, 1, watt32_recv_hook, NULL);
 862
 863   if (len < 0)
 864      return (NULL);
 865
 866   *type = etype;
 867   return (void*) &rxbuf;
 868 }
 869
 870 /*
 871  * This function is called by Watt-32 (via _eth_xmit_hook).
 872  * If dbug_init() was called, we should trace packets sent.
 873  */
 874 static int pcap_xmit_hook (const void *buf, unsigned len)
 875 {
 876   int rc = 0;
 877
 878   if (pcap_pkt_debug > 0)
 879      dbug_write ("pcap_xmit_hook: ");
 880
 881   if (active_dev && active_dev->xmit)
 882      if ((*active_dev->xmit) (active_dev, buf, len) > 0)
 883         rc = len;
 884
 885   if (pcap_pkt_debug > 0)
 886      dbug_write (rc ? "ok\n" : "fail\n");
 887   return (rc);
 888 }
 889 #endif
 890
 891 static int pcap_sendpacket_dos (pcap_t *p, const void *buf, size_t len)
 892 {
 893   struct device *dev = p ? get_device(p->fd) : NULL;
 894
 895   if (!dev || !dev->xmit)
 896      return (-1);
 897   return (*dev->xmit) (dev, buf, len);
 898 }
 899
 900 /*
 901  * This function is called by Watt-32 in tcp_post_init().
 902  * We should prevent Watt-32 from using BOOTP/DHCP/RARP etc.
 903  */
 904 static void (*prev_post_hook) (void);
 905
 906 static void pcap_init_hook (void)
 907 {
 908   _w32__bootp_on = _w32__dhcp_on = _w32__rarp_on = 0;
 909   _w32__do_mask_req = 0;
 910   _w32_dynamic_host = 0;
 911   if (prev_post_hook)
 912     (*prev_post_hook)();
 913 }
 914
 915 /*
 916  * Supress PRINT message from Watt-32's sock_init()
 917  */
 918 static void null_print (void) {}
 919
 920 /*
 921  * To use features of Watt-32 (netdb functions and socket etc.)
 922  * we must call sock_init(). But we set various hooks to prevent
 923  * using normal PKTDRVR functions in pcpkt.c. This should hopefully
 924  * make Watt-32 and pcap co-operate.
 925  */
 926 static int init_watt32 (struct pcap *pcap, const char *dev_name, char *err_buf)
 927 {
 928   char *env;
 929   int   rc, MTU, has_ip_addr;
 930   int   using_pktdrv = 1;
 931
 932   /* If user called sock_init() first, we need to reinit in
 933    * order to open debug/trace-file properly
 934    */
 935   if (_watt_is_init)
 936      sock_exit();
 937
 938   env = getenv ("PCAP_DEBUG");
 939   if (env && atoi(env) > 0 &&
 940       pcap_pkt_debug < 0)   /* if not already set */
 941   {
 942     dbug_init();
 943     pcap_pkt_debug = atoi (env);
 944   }
 945
 946   _watt_do_exit      = 0;    /* prevent sock_init() calling exit() */
 947   prev_post_hook     = _w32_usr_post_init;
 948   _w32_usr_post_init = pcap_init_hook;
 949   _w32_print_hook    = null_print;
 950
 951   if (dev_name && strncmp(dev_name,"pkt",3))
 952      using_pktdrv = FALSE;
 953
 954   rc = sock_init();
 955   has_ip_addr = (rc != 8);  /* IP-address assignment failed */
 956
 957   /* if pcap is using a 32-bit driver w/o a pktdrvr loaded, we
 958    * just pretend Watt-32 is initialised okay.
 959    *
 960    * !! fix-me: The Watt-32 config isn't done if no pktdrvr
 961    *            was found. In that case my_ip_addr + sin_mask
 962    *            have default values. Should be taken from another
 963    *            ini-file/environment in any case (ref. tcpdump.ini)
 964    */
 965   _watt_is_init = 1;
 966
 967   if (!using_pktdrv || !has_ip_addr)  /* for now .... */
 968   {
 969     static const char myip[] = "192.168.0.1";
 970     static const char mask[] = "255.255.255.0";
 971
 972     printf ("Just guessing, using IP %s and netmask %s\n", myip, mask);
 973     my_ip_addr    = aton (myip);
 974     _w32_sin_mask = aton (mask);
 975   }
 976   else if (rc && using_pktdrv)
 977   {
 978     sprintf (err_buf, "sock_init() failed, code %d", rc);
 979     return (0);
 980   }
 981
 982   /* Set recv-hook for peeking in _eth_arrived().
 983    */
 984 #if (WATTCP_VER >= 0x0224)
 985   _eth_recv_hook = pcap_recv_hook;
 986   _eth_xmit_hook = pcap_xmit_hook;
 987 #endif
 988
 989   /* Free the pkt-drvr handle allocated in pkt_init().
 990    * The above hooks should thus use the handle reopened in open_driver()
 991    */
 992   if (using_pktdrv)
 993   {
 994     _eth_release();
 995 /*  _eth_is_init = 1; */  /* hack to get Rx/Tx-hooks in Watt-32 working */
 996   }
 997
 998   memcpy (&pcap_save, pcap, sizeof(pcap_save));
 999   MTU = pkt_get_mtu();
1000   pcap_save.fcode.bf_insns = NULL;
1001   pcap_save.linktype       = _eth_get_hwtype (NULL, NULL);
1002   pcap_save.snapshot       = MTU > 0 ? MTU : ETH_MAX; /* assume 1514 */
1003
1004 #if 1
1005   /* prevent use of resolve() and resolve_ip()
1006    */
1007   last_nameserver = 0;
1008 #endif
1009   return (1);
1010 }
1011
1012 int EISA_bus = 0;  /* Where is natural place for this? */
1013
1014 /*
1015  * Application config hooks to set various driver parameters.
1016  */
1017
1018 static const struct config_table debug_tab[] = {
1019             { "PKT.DEBUG",       ARG_ATOI,   &pcap_pkt_debug    },
1020             { "PKT.VECTOR",      ARG_ATOX_W, NULL               },
1021             { "NDIS.DEBUG",      ARG_ATOI,   NULL               },
1022 #ifdef USE_32BIT_DRIVERS
1023             { "3C503.DEBUG",     ARG_ATOI,   &ei_debug          },
1024             { "3C503.IO_BASE",   ARG_ATOX_W, &el2_dev.base_addr },
1025             { "3C503.MEMORY",    ARG_ATOX_W, &el2_dev.mem_start },
1026             { "3C503.IRQ",       ARG_ATOI,   &el2_dev.irq       },
1027             { "3C505.DEBUG",     ARG_ATOI,   NULL               },
1028             { "3C505.BASE",      ARG_ATOX_W, NULL               },
1029             { "3C507.DEBUG",     ARG_ATOI,   NULL               },
1030             { "3C509.DEBUG",     ARG_ATOI,   &el3_debug         },
1031             { "3C509.ILOOP",     ARG_ATOI,   &el3_max_loop      },
1032             { "3C529.DEBUG",     ARG_ATOI,   NULL               },
1033             { "3C575.DEBUG",     ARG_ATOI,   &debug_3c575       },
1034             { "3C59X.DEBUG",     ARG_ATOI,   &vortex_debug      },
1035             { "3C59X.IFACE0",    ARG_ATOI,   &vortex_options[0] },
1036             { "3C59X.IFACE1",    ARG_ATOI,   &vortex_options[1] },
1037             { "3C59X.IFACE2",    ARG_ATOI,   &vortex_options[2] },
1038             { "3C59X.IFACE3",    ARG_ATOI,   &vortex_options[3] },
1039             { "3C90X.DEBUG",     ARG_ATOX_W, &tc90xbc_debug     },
1040             { "ACCT.DEBUG",      ARG_ATOI,   &ethpk_debug       },
1041             { "CS89.DEBUG",      ARG_ATOI,   &cs89_debug        },
1042             { "RTL8139.DEBUG",   ARG_ATOI,   &rtl8139_debug     },
1043         /*  { "RTL8139.FDUPLEX", ARG_ATOI,   &rtl8139_options   }, */
1044             { "SMC.DEBUG",       ARG_ATOI,   &ei_debug          },
1045         /*  { "E100.DEBUG",      ARG_ATOI,   &e100_debug        }, */
1046             { "PCI.DEBUG",       ARG_ATOI,   &pci_debug         },
1047             { "BIOS32.DEBUG",    ARG_ATOI,   &bios32_debug      },
1048             { "IRQ.DEBUG",       ARG_ATOI,   &irq_debug         },
1049             { "TIMER.IRQ",       ARG_ATOI,   &timer_irq         },
1050 #endif
1051             { NULL }
1052           };
1053
1054 /*
1055  * pcap_config_hook() is an extension to application's config
1056  * handling. Uses Watt-32's config-table function.
1057  */
1058 int pcap_config_hook (const char *name, const char *value)
1059 {
1060   return parse_config_table (debug_tab, NULL, name, value);
1061 }
1062
1063 /*
1064  * Linked list of supported devices
1065  */
1066 struct device       *active_dev = NULL;      /* the device we have opened */
1067 struct device       *probed_dev = NULL;      /* the device we have probed */
1068 const struct device *dev_base   = &pkt_dev;  /* list of network devices */
1069
1070 /*
1071  * PKTDRVR device functions
1072  */
1073 int pcap_pkt_debug = -1;
1074
1075 static void pkt_close (struct device *dev)
1076 {
1077   BOOL okay = PktExitDriver();
1078
1079   if (pcap_pkt_debug > 1)
1080      fprintf (stderr, "pkt_close(): %d\n", okay);
1081
1082   if (dev->priv)
1083      free (dev->priv);
1084   dev->priv = NULL;
1085 }
1086
1087 static int pkt_open (struct device *dev)
1088 {
1089   PKT_RX_MODE mode;
1090
1091   if (dev->flags & IFF_PROMISC)
1092        mode = PDRX_ALL_PACKETS;
1093   else mode = PDRX_BROADCAST;
1094
1095   if (!PktInitDriver(mode))
1096      return (0);
1097
1098   PktResetStatistics (pktInfo.handle);
1099   PktQueueBusy (FALSE);
1100   return (1);
1101 }
1102
1103 static int pkt_xmit (struct device *dev, const void *buf, int len)
1104 {
1105   struct net_device_stats *stats = (struct net_device_stats*) dev->priv;
1106
1107   if (pcap_pkt_debug > 0)
1108      dbug_write ("pcap_xmit\n");
1109
1110   if (!PktTransmit(buf,len))
1111   {
1112     stats->tx_errors++;
1113     return (0);
1114   }
1115   return (len);
1116 }
1117
1118 static void *pkt_stats (struct device *dev)
1119 {
1120   struct net_device_stats *stats = (struct net_device_stats*) dev->priv;
1121
1122   if (!stats || !PktSessStatistics(pktInfo.handle))
1123      return (NULL);
1124
1125   stats->rx_packets       = pktStat.inPackets;
1126   stats->rx_errors        = pktStat.lost;
1127   stats->rx_missed_errors = PktRxDropped();
1128   return (stats);
1129 }
1130
1131 static int pkt_probe (struct device *dev)
1132 {
1133   if (!PktSearchDriver())
1134      return (0);
1135
1136   dev->open           = pkt_open;
1137   dev->xmit           = pkt_xmit;
1138   dev->close          = pkt_close;
1139   dev->get_stats      = pkt_stats;
1140   dev->copy_rx_buf    = PktReceive;  /* farmem peek and copy routine */
1141   dev->get_rx_buf     = NULL;
1142   dev->peek_rx_buf    = NULL;
1143   dev->release_rx_buf = NULL;
1144   dev->priv           = calloc (sizeof(struct net_device_stats), 1);
1145   if (!dev->priv)
1146      return (0);
1147   return (1);
1148 }
1149
1150 /*
1151  * NDIS device functions
1152  */
1153 static void ndis_close (struct device *dev)
1154 {
1155 #ifdef USE_NDIS2
1156   NdisShutdown();
1157 #endif
1158   ARGSUSED (dev);
1159 }
1160
1161 static int ndis_open (struct device *dev)
1162 {
1163   int promis = (dev->flags & IFF_PROMISC);
1164
1165 #ifdef USE_NDIS2
1166   if (!NdisInit(promis))
1167      return (0);
1168   return (1);
1169 #else
1170   ARGSUSED (promis);
1171   return (0);
1172 #endif
1173 }
1174
1175 static void *ndis_stats (struct device *dev)
1176 {
1177   static struct net_device_stats stats;
1178
1179   /* to-do */
1180   ARGSUSED (dev);
1181   return (&stats);
1182 }
1183
1184 static int ndis_probe (struct device *dev)
1185 {
1186 #ifdef USE_NDIS2
1187   if (!NdisOpen())
1188      return (0);
1189 #endif
1190
1191   dev->open           = ndis_open;
1192   dev->xmit           = NULL;
1193   dev->close          = ndis_close;
1194   dev->get_stats      = ndis_stats;
1195   dev->copy_rx_buf    = NULL;       /* to-do */
1196   dev->get_rx_buf     = NULL;       /* upcall is from rmode driver */
1197   dev->peek_rx_buf    = NULL;
1198   dev->release_rx_buf = NULL;
1199   return (0);
1200 }
1201
1202 /*
1203  * Search & probe for supported 32-bit (pmode) pcap devices
1204  */
1205 #if defined(USE_32BIT_DRIVERS)
1206
1207 struct device el2_dev LOCKED_VAR = {
1208               "3c503",
1209               "EtherLink II",
1210               0,
1211               0,0,0,0,0,0,
1212               NULL,
1213               el2_probe
1214             };
1215
1216 struct device el3_dev LOCKED_VAR = {
1217               "3c509",
1218               "EtherLink III",
1219               0,
1220               0,0,0,0,0,0,
1221               &el2_dev,
1222               el3_probe
1223             };
1224
1225 struct device tc515_dev LOCKED_VAR = {
1226               "3c515",
1227               "EtherLink PCI",
1228               0,
1229               0,0,0,0,0,0,
1230               &el3_dev,
1231               tc515_probe
1232             };
1233
1234 struct device tc59_dev LOCKED_VAR = {
1235               "3c59x",
1236               "EtherLink PCI",
1237               0,
1238               0,0,0,0,0,0,
1239               &tc515_dev,
1240               tc59x_probe
1241             };
1242
1243 struct device tc90xbc_dev LOCKED_VAR = {
1244               "3c90x",
1245               "EtherLink 90X",
1246               0,
1247               0,0,0,0,0,0,
1248               &tc59_dev,
1249               tc90xbc_probe
1250             };
1251
1252 struct device wd_dev LOCKED_VAR = {
1253               "wd",
1254               "Westen Digital",
1255               0,
1256               0,0,0,0,0,0,
1257               &tc90xbc_dev,
1258               wd_probe
1259             };
1260
1261 struct device ne_dev LOCKED_VAR = {
1262               "ne",
1263               "NEx000",
1264               0,
1265               0,0,0,0,0,0,
1266               &wd_dev,
1267               ne_probe
1268             };
1269
1270 struct device acct_dev LOCKED_VAR = {
1271               "acct",
1272               "Accton EtherPocket",
1273               0,
1274               0,0,0,0,0,0,
1275               &ne_dev,
1276               ethpk_probe
1277             };
1278
1279 struct device cs89_dev LOCKED_VAR = {
1280               "cs89",
1281               "Crystal Semiconductor",
1282               0,
1283               0,0,0,0,0,0,
1284               &acct_dev,
1285               cs89x0_probe
1286             };
1287
1288 struct device rtl8139_dev LOCKED_VAR = {
1289               "rtl8139",
1290               "RealTek PCI",
1291               0,
1292               0,0,0,0,0,0,
1293               &cs89_dev,
1294               rtl8139_probe     /* dev->probe routine */
1295             };
1296
1297 /*
1298  * Dequeue routine is called by polling.
1299  * NOTE: the queue-element is not copied, only a pointer is
1300  * returned at '*buf'
1301  */
1302 int peek_rxbuf (BYTE **buf)
1303 {
1304   struct rx_elem *tail, *head;
1305
1306   PCAP_ASSERT (pktq_check (&active_dev->queue));
1307
1308   DISABLE();
1309   tail = pktq_out_elem (&active_dev->queue);
1310   head = pktq_in_elem (&active_dev->queue);
1311   ENABLE();
1312
1313   if (head != tail)
1314   {
1315     PCAP_ASSERT (tail->size < active_dev->queue.elem_size-4-2);
1316
1317     *buf = &tail->data[0];
1318     return (tail->size);
1319   }
1320   *buf = NULL;
1321   return (0);
1322 }
1323
1324 /*
1325  * Release buffer we peeked at above.
1326  */
1327 int release_rxbuf (BYTE *buf)
1328 {
1329 #ifndef NDEBUG
1330   struct rx_elem *tail = pktq_out_elem (&active_dev->queue);
1331
1332   PCAP_ASSERT (&tail->data[0] == buf);
1333 #else
1334   ARGSUSED (buf);
1335 #endif
1336   pktq_inc_out (&active_dev->queue);
1337   return (1);
1338 }
1339
1340 /*
1341  * get_rxbuf() routine (in locked code) is called from IRQ handler
1342  * to request a buffer. Interrupts are disabled and we have a 32kB stack.
1343  */
1344 BYTE *get_rxbuf (int len)
1345 {
1346   int idx;
1347
1348   if (len < ETH_MIN || len > ETH_MAX)
1349      return (NULL);
1350
1351   idx = pktq_in_index (&active_dev->queue);
1352
1353 #ifdef DEBUG
1354   {
1355     static int fan_idx LOCKED_VAR = 0;
1356     writew ("-\\|/"[fan_idx++] | (15 << 8),      /* white on black colour */
1357             0xB8000 + 2*79);  /* upper-right corner, 80-col colour screen */
1358     fan_idx &= 3;
1359   }
1360 /* writew (idx + '0' + 0x0F00, 0xB8000 + 2*78); */
1361 #endif
1362
1363   if (idx != active_dev->queue.out_index)
1364   {
1365     struct rx_elem *head = pktq_in_elem (&active_dev->queue);
1366
1367     head->size = len;
1368     active_dev->queue.in_index = idx;
1369     return (&head->data[0]);
1370   }
1371
1372   /* !!to-do: drop 25% of the oldest element
1373    */
1374   pktq_clear (&active_dev->queue);
1375   return (NULL);
1376 }
1377
1378 /*
1379  *  Simple ring-buffer queue handler for reception of packets
1380  *  from network driver.
1381  */
1382 #define PKTQ_MARKER  0xDEADBEEF
1383
1384 static int pktq_check (struct rx_ringbuf *q)
1385 {
1386 #ifndef NDEBUG
1387   int   i;
1388   char *buf;
1389 #endif
1390
1391   if (!q || !q->num_elem || !q->buf_start)
1392      return (0);
1393
1394 #ifndef NDEBUG
1395   buf = q->buf_start;
1396
1397   for (i = 0; i < q->num_elem; i++)
1398   {
1399     buf += q->elem_size;
1400     if (*(DWORD*)(buf - sizeof(DWORD)) != PKTQ_MARKER)
1401        return (0);
1402   }
1403 #endif
1404   return (1);
1405 }
1406
1407 static int pktq_init (struct rx_ringbuf *q, int size, int num, char *pool)
1408 {
1409   int i;
1410
1411   q->elem_size = size;
1412   q->num_elem  = num;
1413   q->buf_start = pool;
1414   q->in_index  = 0;
1415   q->out_index = 0;
1416
1417   PCAP_ASSERT (size >= sizeof(struct rx_elem) + sizeof(DWORD));
1418   PCAP_ASSERT (num);
1419   PCAP_ASSERT (pool);
1420
1421   for (i = 0; i < num; i++)
1422   {
1423 #if 0
1424     struct rx_elem *elem = (struct rx_elem*) pool;
1425
1426     /* assert dword aligned elements
1427      */
1428     PCAP_ASSERT (((unsigned)(&elem->data[0]) & 3) == 0);
1429 #endif
1430     pool += size;
1431     *(DWORD*) (pool - sizeof(DWORD)) = PKTQ_MARKER;
1432   }
1433   return (1);
1434 }
1435
1436 /*
1437  * Increment the queue 'out_index' (tail).
1438  * Check for wraps.
1439  */
1440 static int pktq_inc_out (struct rx_ringbuf *q)
1441 {
1442   q->out_index++;
1443   if (q->out_index >= q->num_elem)
1444       q->out_index = 0;
1445   return (q->out_index);
1446 }
1447
1448 /*
1449  * Return the queue's next 'in_index' (head).
1450  * Check for wraps.
1451  */
1452 static int pktq_in_index (struct rx_ringbuf *q)
1453 {
1454   volatile int index = q->in_index + 1;
1455
1456   if (index >= q->num_elem)
1457       index = 0;
1458   return (index);
1459 }
1460
1461 /*
1462  * Return the queue's head-buffer.
1463  */
1464 static struct rx_elem *pktq_in_elem (struct rx_ringbuf *q)
1465 {
1466   return (struct rx_elem*) (q->buf_start + (q->elem_size * q->in_index));
1467 }
1468
1469 /*
1470  * Return the queue's tail-buffer.
1471  */
1472 static struct rx_elem *pktq_out_elem (struct rx_ringbuf *q)
1473 {
1474   return (struct rx_elem*) (q->buf_start + (q->elem_size * q->out_index));
1475 }
1476
1477 /*
1478  * Clear the queue ring-buffer by setting head=tail.
1479  */
1480 static void pktq_clear (struct rx_ringbuf *q)
1481 {
1482   q->in_index = q->out_index;
1483 }
1484
1485 /*
1486  * Symbols that must be linkable for "gcc -O0"
1487  */
1488 #undef __IOPORT_H
1489 #undef __DMA_H
1490
1491 #define extern
1492 #define __inline__
1493
1494 #include "msdos/pm_drvr/ioport.h"
1495 #include "msdos/pm_drvr/dma.h"
1496
1497 #endif /* USE_32BIT_DRIVERS */
1498