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