nexmon – Blame information for rev 1

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