The Tcpdump Group git mirrors - libpcap/blob - pcap-dos.c

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