• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  */
77 extern WORD  _pktdevclass;
78 extern BOOL  _eth_is_init;
79 extern int   _w32_dynamic_host;
80 extern int   _watt_do_exit;
81 extern int   _watt_is_init;
82 extern int   _w32__bootp_on, _w32__dhcp_on, _w32__rarp_on, _w32__do_mask_req;
83 extern void (*_w32_usr_post_init) (void);
84 extern void (*_w32_print_hook)();
85 
86 extern void dbug_write (const char *);  /* Watt-32 lib, pcdbug.c */
87 extern int  pkt_get_mtu (void);
88 
89 static int ref_count = 0;
90 
91 static u_long mac_count    = 0;
92 static u_long filter_count = 0;
93 
94 static volatile BOOL exc_occured = 0;
95 
96 static struct device *handle_to_device [20];
97 
98 static int  pcap_activate_dos (pcap_t *p);
99 static int  pcap_read_dos (pcap_t *p, int cnt, pcap_handler callback,
100                            u_char *data);
101 static void pcap_cleanup_dos (pcap_t *p);
102 static int  pcap_stats_dos (pcap_t *p, struct pcap_stat *ps);
103 static int  pcap_sendpacket_dos (pcap_t *p, const void *buf, size_t len);
104 static int  pcap_setfilter_dos (pcap_t *p, struct bpf_program *fp);
105 
106 static int  ndis_probe (struct device *dev);
107 static int  pkt_probe  (struct device *dev);
108 
109 static void close_driver (void);
110 static int  init_watt32 (struct pcap *pcap, const char *dev_name, char *err_buf);
111 static int  first_init (const char *name, char *ebuf, int promisc);
112 
113 static void watt32_recv_hook (u_char *dummy, const struct pcap_pkthdr *pcap,
114                               const u_char *buf);
115 
116 /*
117  * These are the device we always support
118  */
119 static struct device ndis_dev = {
120               "ndis",
121               "NDIS2 LanManager",
122               0,
123               0,0,0,0,0,0,
124               NDIS_NEXT_DEV,  /* NULL or a 32-bit device */
125               ndis_probe
126             };
127 
128 static struct device pkt_dev = {
129               "pkt",
130               "Packet-Driver",
131               0,
132               0,0,0,0,0,0,
133               &ndis_dev,
134               pkt_probe
135             };
136 
get_device(int fd)137 static struct device *get_device (int fd)
138 {
139   if (fd <= 0 || fd >= sizeof(handle_to_device)/sizeof(handle_to_device[0]))
140      return (NULL);
141   return handle_to_device [fd-1];
142 }
143 
144 /*
145  * Private data for capturing on MS-DOS.
146  */
147 struct pcap_dos {
148 	void (*wait_proc)(void); /* call proc while waiting */
149 	struct pcap_stat stat;
150 };
151 
pcap_create_interface(const char * device _U_,char * ebuf)152 pcap_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  */
pcap_activate_dos(pcap_t * pcap)168 static 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  */
232 static int
pcap_read_one(pcap_t * p,pcap_handler callback,u_char * data)233 pcap_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 
353 static int
pcap_read_dos(pcap_t * p,int cnt,pcap_handler callback,u_char * data)354 pcap_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  */
pcap_stats_dos(pcap_t * p,struct pcap_stat * ps)375 static 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  */
pcap_stats_ex(pcap_t * p,struct pcap_stat_ex * se)410 int 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     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     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  */
pcap_setfilter_dos(pcap_t * p,struct bpf_program * fp)436 static 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  */
pcap_mac_packets(void)447 u_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  */
pcap_filter_packets(void)455 u_long pcap_filter_packets (void)
456 {
457   return (filter_count);
458 }
459 
460 /*
461  * Close pcap device. Not called for offline captures.
462  */
pcap_cleanup_dos(pcap_t * p)463 static 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  */
pcap_lookupdev(char * ebuf)490 char *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  */
pcap_lookupnet(const char * device,bpf_u_int32 * localnet,bpf_u_int32 * netmask,char * errbuf)518 int 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  */
pcap_platform_finddevs(pcap_if_list_t * devlistp,char * errbuf)558 int 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  */
pcap_assert(const char * what,const char * file,unsigned line)625 void 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  */
pcap_set_wait(pcap_t * p,void (* yield)(void),int wait)638 void 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  */
652 static struct device *
open_driver(const char * dev_name,char * ebuf,int promisc)653 open_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 
718 not_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  */
close_driver(void)731 static 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__
setup_signals(void (* handler)(int))757 static void setup_signals (void (*handler)(int))
758 {
759   signal (SIGSEGV,handler);
760   signal (SIGILL, handler);
761   signal (SIGFPE, handler);
762 }
763 
exc_handler(int sig)764 static 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  */
first_init(const char * name,char * ebuf,int promisc)799 static 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
init_32bit(void)852 static 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  */
869 static char rxbuf [ETH_MAX+100]; /* rx-buffer with some margin */
870 static WORD etype;
871 static pcap_t pcap_save;
872 
watt32_recv_hook(u_char * dummy,const struct pcap_pkthdr * pcap,const u_char * buf)873 static 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  */
pcap_recv_hook(WORD * type)889 static 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  */
pcap_xmit_hook(const void * buf,unsigned len)904 static 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 
pcap_sendpacket_dos(pcap_t * p,const void * buf,size_t len)921 static 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  */
934 static void (*prev_post_hook) (void);
935 
pcap_init_hook(void)936 static 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  */
null_print(void)948 static 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  */
init_watt32(struct pcap * pcap,const char * dev_name,char * err_buf)956 static 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 
1042 int EISA_bus = 0;  /* Where is natural place for this? */
1043 
1044 /*
1045  * Application config hooks to set various driver parameters.
1046  */
1047 
1048 static 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  */
pcap_config_hook(const char * keyword,const char * value)1088 int 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  */
1096 struct device       *active_dev = NULL;      /* the device we have opened */
1097 struct device       *probed_dev = NULL;      /* the device we have probed */
1098 const struct device *dev_base   = &pkt_dev;  /* list of network devices */
1099 
1100 /*
1101  * PKTDRVR device functions
1102  */
1103 int pcap_pkt_debug = -1;
1104 
pkt_close(struct device * dev)1105 static 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 
pkt_open(struct device * dev)1117 static 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 
pkt_xmit(struct device * dev,const void * buf,int len)1133 static 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 
pkt_stats(struct device * dev)1148 static 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 
pkt_probe(struct device * dev)1161 static 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  */
ndis_close(struct device * dev)1183 static void ndis_close (struct device *dev)
1184 {
1185 #ifdef USE_NDIS2
1186   NdisShutdown();
1187 #endif
1188   ARGSUSED (dev);
1189 }
1190 
ndis_open(struct device * dev)1191 static 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 
ndis_stats(struct device * dev)1205 static 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 
ndis_probe(struct device * dev)1214 static 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 
1237 struct 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 
1246 struct 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 
1255 struct 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 
1264 struct 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 
1273 struct 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 
1282 struct 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 
1291 struct 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 
1300 struct 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 
1309 struct 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 
1318 struct 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  */
peek_rxbuf(BYTE ** buf)1332 int 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  */
release_rxbuf(BYTE * buf)1357 int 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  */
get_rxbuf(int len)1374 BYTE *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 
pktq_check(struct rx_ringbuf * q)1414 static 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 
pktq_init(struct rx_ringbuf * q,int size,int num,char * pool)1437 static 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  */
pktq_inc_out(struct rx_ringbuf * q)1470 static 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  */
pktq_in_index(struct rx_ringbuf * q)1482 static 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  */
pktq_in_elem(struct rx_ringbuf * q)1494 static 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  */
pktq_out_elem(struct rx_ringbuf * q)1502 static 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  */
pktq_clear(struct rx_ringbuf * q)1510 static 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  */
1532 const char *
pcap_lib_version(void)1533 pcap_lib_version(void)
1534 {
1535   return ("DOS-" PCAP_VERSION_STRING);
1536 }
1537