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