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