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