]> The Tcpdump Group git mirrors - libpcap/blob - pcap-dos.c
projects / libpcap / blob


c852817ca0190a7a7eeed6c4661f94a220fb7532
[libpcap] / pcap-dos.c
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
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 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
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
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 *
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 */
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__
741 static void setup_signals (void (*handler)(int))
742 {
743 signal (SIGSEGV,handler);
744 signal (SIGILL, handler);
745 signal (SIGFPE, handler);
746 }
747
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 */
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
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
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 */
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 */
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
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
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 */
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 */
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 */
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
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
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
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
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
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 */
1167 static void ndis_close (struct device *dev)
1168 {
1169 #ifdef USE_NDIS2
1170 NdisShutdown();
1171 #endif
1172 ARGSUSED (dev);
1173 }
1174
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
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
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 */
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 */
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 */
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
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
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 */
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 */
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 */
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 */
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 */
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
[mirror] the LIBpcap interface to various kernel packet capture mechanism