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