/* * VARCem Virtual ARchaeological Computer EMulator. * An emulator of (mostly) x86-based PC systems and devices, * using the ISA,EISA,VLB,MCA and PCI system buses, roughly * spanning the era between 1981 and 1995. * * Handle WinPcap library processing. * * * * Authors: Fred N. van Kempen, * * Copyright 2017-2019 Fred N. van Kempen. * * Redistribution and use in source and binary forms, with * or without modification, are permitted provided that the * following conditions are met: * * 1. Redistributions of source code must retain the entire * above notice, this list of conditions and the following * disclaimer. * * 2. Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the * following disclaimer in the documentation and/or other * materials provided with the distribution. * * 3. Neither the name of the copyright holder nor the names * of its contributors may be used to endorse or promote * products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #ifdef _WIN32 # define WIN32_LEAN_AND_MEAN # include # include #else # include # include # include # include #endif #define HAVE_STDARG_H #include <86box/86box.h> #include <86box/device.h> #include <86box/plat.h> #include <86box/plat_dynld.h> #include <86box/thread.h> #include <86box/timer.h> #include <86box/network.h> #include <86box/net_event.h> #define PCAP_PKT_BATCH NET_QUEUE_LEN enum { NET_EVENT_STOP = 0, NET_EVENT_TX, NET_EVENT_RX, NET_EVENT_MAX }; #ifdef __APPLE__ # include #else typedef int bpf_int32; typedef unsigned int bpf_u_int32; /* * The instruction data structure. */ struct bpf_insn { unsigned short code; unsigned char jt; unsigned char jf; bpf_u_int32 k; }; /* * Structure for "pcap_compile()", "pcap_setfilter()", etc.. */ struct bpf_program { unsigned int bf_len; struct bpf_insn *bf_insns; }; typedef struct pcap_if pcap_if_t; # define PCAP_ERRBUF_SIZE 256 struct pcap_pkthdr { struct timeval ts; bpf_u_int32 caplen; bpf_u_int32 len; }; struct pcap_if { struct pcap_if *next; char *name; char *description; void *addresses; bpf_u_int32 flags; }; struct pcap_send_queue { unsigned int maxlen; /* Maximum size of the queue, in bytes. This variable contains the size of the buffer field. */ unsigned int len; /* Current size of the queue, in bytes. */ char *buffer; /* Buffer containing the packets to be sent. */ }; typedef struct pcap_send_queue pcap_send_queue; typedef void (*pcap_handler)(unsigned char *user, const struct pcap_pkthdr *h, const unsigned char *bytes); #endif typedef struct { void *pcap; /* handle to pcap lib instance */ netcard_t *card; /* netcard linked to us */ thread_t *poll_tid; net_evt_t tx_event; net_evt_t stop_event; netpkt_t pkt; netpkt_t pktv[PCAP_PKT_BATCH]; uint8_t mac_addr[6]; #ifdef _WIN32 struct pcap_send_queue *pcap_queue; #endif } net_pcap_t; typedef struct { char *intf_name; uint8_t *mac_addr; } net_pcap_params_t; static volatile void *libpcap_handle; /* handle to WinPcap DLL */ /* Pointers to the real functions. */ static const char *(*f_pcap_lib_version)(void); static int (*f_pcap_findalldevs)(pcap_if_t **, char *); static void (*f_pcap_freealldevs)(void *); static void *(*f_pcap_open_live)(const char *, int, int, int, char *); static int (*f_pcap_compile)(void *, void *, const char *, int, bpf_u_int32); static int (*f_pcap_setfilter)(void *, void *); static const unsigned char *(*f_pcap_next)(void *, void *); static int (*f_pcap_sendpacket)(void *, const unsigned char *, int); static void (*f_pcap_close)(void *); static int (*f_pcap_setnonblock)(void *, int, char *); static int (*f_pcap_set_immediate_mode)(void *, int); static int (*f_pcap_set_promisc)(void *, int); static int (*f_pcap_set_snaplen)(void *, int); static int (*f_pcap_dispatch)(void *, int, pcap_handler callback, unsigned char *user); static void *(*f_pcap_create)(const char *, char *); static int (*f_pcap_activate)(void *); static void *(*f_pcap_geterr)(void *); #ifdef _WIN32 static HANDLE (*f_pcap_getevent)(void *); static int (*f_pcap_sendqueue_queue)(void *, void *, void *); static unsigned int (*f_pcap_sendqueue_transmit)(void *, void *, int sync); static void *(*f_pcap_sendqueue_alloc)(unsigned int memsize); static void (*f_pcap_sendqueue_destroy)(void *); #else static int (*f_pcap_get_selectable_fd)(void *); #endif static dllimp_t pcap_imports[] = { {"pcap_lib_version", &f_pcap_lib_version }, { "pcap_findalldevs", &f_pcap_findalldevs }, { "pcap_freealldevs", &f_pcap_freealldevs }, { "pcap_open_live", &f_pcap_open_live }, { "pcap_compile", &f_pcap_compile }, { "pcap_setfilter", &f_pcap_setfilter }, { "pcap_next", &f_pcap_next }, { "pcap_sendpacket", &f_pcap_sendpacket }, { "pcap_close", &f_pcap_close }, { "pcap_setnonblock", &f_pcap_setnonblock }, { "pcap_set_immediate_mode", &f_pcap_set_immediate_mode}, { "pcap_set_promisc", &f_pcap_set_promisc }, { "pcap_set_snaplen", &f_pcap_set_snaplen }, { "pcap_dispatch", &f_pcap_dispatch }, { "pcap_create", &f_pcap_create }, { "pcap_activate", &f_pcap_activate }, { "pcap_geterr", &f_pcap_geterr }, #ifdef _WIN32 { "pcap_getevent", &f_pcap_getevent }, { "pcap_sendqueue_queue", &f_pcap_sendqueue_queue }, { "pcap_sendqueue_transmit", &f_pcap_sendqueue_transmit}, { "pcap_sendqueue_alloc", &f_pcap_sendqueue_alloc }, { "pcap_sendqueue_destroy", &f_pcap_sendqueue_destroy }, #else { "pcap_get_selectable_fd", &f_pcap_get_selectable_fd }, #endif { NULL, NULL }, }; #ifdef ENABLE_PCAP_LOG int pcap_do_log = ENABLE_PCAP_LOG; static void pcap_log(const char *fmt, ...) { va_list ap; if (pcap_do_log) { va_start(ap, fmt); pclog_ex(fmt, ap); va_end(ap); } } #else # define pcap_log(fmt, ...) #endif static void net_pcap_rx_handler(uint8_t *user, const struct pcap_pkthdr *h, const uint8_t *bytes) { net_pcap_t *pcap = (net_pcap_t *) user; memcpy(pcap->pkt.data, bytes, h->caplen); pcap->pkt.len = h->caplen; network_rx_put_pkt(pcap->card, &pcap->pkt); } /* Send a packet to the Pcap interface. */ void net_pcap_in(void *pcap, uint8_t *bufp, int len) { if (pcap == NULL) return; f_pcap_sendpacket(pcap, bufp, len); } void net_pcap_in_available(void *priv) { net_pcap_t *pcap = (net_pcap_t *) priv; net_event_set(&pcap->tx_event); } #ifdef _WIN32 static void net_pcap_thread(void *priv) { net_pcap_t *pcap = (net_pcap_t *) priv; pcap_log("PCAP: polling started.\n"); HANDLE events[NET_EVENT_MAX]; events[NET_EVENT_STOP] = net_event_get_handle(&pcap->stop_event); events[NET_EVENT_TX] = net_event_get_handle(&pcap->tx_event); events[NET_EVENT_RX] = f_pcap_getevent(pcap->pcap); bool run = true; struct pcap_pkthdr h; while (run) { int ret = WaitForMultipleObjects(NET_EVENT_MAX, events, FALSE, INFINITE); switch (ret - WAIT_OBJECT_0) { case NET_EVENT_STOP: net_event_clear(&pcap->stop_event); run = false; break; case NET_EVENT_TX: net_event_clear(&pcap->tx_event); int packets = network_tx_popv(pcap->card, pcap->pktv, PCAP_PKT_BATCH); for (int i = 0; i < packets; i++) { h.caplen = pcap->pktv[i].len; f_pcap_sendqueue_queue(pcap->pcap_queue, &h, pcap->pktv[i].data); } f_pcap_sendqueue_transmit(pcap->pcap, pcap->pcap_queue, 0); pcap->pcap_queue->len = 0; break; case NET_EVENT_RX: f_pcap_dispatch(pcap->pcap, PCAP_PKT_BATCH, net_pcap_rx_handler, (unsigned char *) pcap); break; default: break; } } pcap_log("PCAP: polling stopped.\n"); } #else static void net_pcap_thread(void *priv) { net_pcap_t *pcap = (net_pcap_t *) priv; pcap_log("PCAP: polling started.\n"); struct pollfd pfd[NET_EVENT_MAX]; pfd[NET_EVENT_STOP].fd = net_event_get_fd(&pcap->stop_event); pfd[NET_EVENT_STOP].events = POLLIN | POLLPRI; pfd[NET_EVENT_TX].fd = net_event_get_fd(&pcap->tx_event); pfd[NET_EVENT_TX].events = POLLIN | POLLPRI; pfd[NET_EVENT_RX].fd = f_pcap_get_selectable_fd((void *) pcap->pcap); pfd[NET_EVENT_RX].events = POLLIN | POLLPRI; /* As long as the channel is open.. */ while (1) { poll(pfd, NET_EVENT_MAX, -1); if (pfd[NET_EVENT_STOP].revents & POLLIN) { net_event_clear(&pcap->stop_event); break; } if (pfd[NET_EVENT_TX].revents & POLLIN) { net_event_clear(&pcap->tx_event); int packets = network_tx_popv(pcap->card, pcap->pktv, PCAP_PKT_BATCH); for (int i = 0; i < packets; i++) { net_pcap_in(pcap->pcap, pcap->pktv[i].data, pcap->pktv[i].len); } } if (pfd[NET_EVENT_RX].revents & POLLIN) { f_pcap_dispatch(pcap->pcap, PCAP_PKT_BATCH, net_pcap_rx_handler, (unsigned char *) pcap); } } pcap_log("PCAP: polling stopped.\n"); } #endif /* * Prepare the (Win)Pcap module for use. * * This is called only once, during application init, * to check for availability of PCAP, and to retrieve * a list of (usable) intefaces for it. */ int net_pcap_prepare(netdev_t *list) { char errbuf[PCAP_ERRBUF_SIZE]; pcap_if_t *devlist; int i = 0; /* Try loading the DLL. */ #ifdef _WIN32 /* Add the Npcap directory to the DLL search path. */ char npcap_dir[512]; GetSystemDirectoryA(npcap_dir, 480); strcat(npcap_dir, "\\Npcap"); SetDllDirectoryA(npcap_dir); libpcap_handle = dynld_module("wpcap.dll", pcap_imports); SetDllDirectoryA(NULL); /* reset the DLL search path */ #elif defined __APPLE__ libpcap_handle = dynld_module("libpcap.dylib", pcap_imports); #else libpcap_handle = dynld_module("libpcap.so", pcap_imports); #endif if (libpcap_handle == NULL) { pcap_log("PCAP: error loading pcap module\n"); return (-1); } /* Retrieve the device list from the local machine */ if (f_pcap_findalldevs(&devlist, errbuf) == -1) { pcap_log("PCAP: error in pcap_findalldevs: %s\n", errbuf); return (-1); } for (pcap_if_t *dev = devlist; dev != NULL; dev = dev->next) { if (i >= (NET_HOST_INTF_MAX - 1)) break; /** * we initialize the strings to NULL first for strncpy */ memset(list->device, '\0', sizeof(list->device)); memset(list->description, '\0', sizeof(list->description)); strncpy(list->device, dev->name, sizeof(list->device) - 1); if (dev->description) { strncpy(list->description, dev->description, sizeof(list->description) - 1); } else { /* if description is NULL, set the name. This allows pcap to display *something* useful under WINE */ strncpy(list->description, dev->name, sizeof(list->description) - 1); } list++; i++; } /* Release the memory. */ f_pcap_freealldevs(devlist); return i; } /* * Copy error message to the error buffer * and log if enabled. */ void net_pcap_error(char *errbuf, const char *message) { strncpy(errbuf, message, NET_DRV_ERRBUF_SIZE); pcap_log("PCAP: %s\n", message); } /* * Initialize (Win)Pcap for use. * * We already know we have PCAP available, as this * is called when the network activates itself and * tries to attach to the network module. */ void * net_pcap_init(const netcard_t *card, const uint8_t *mac_addr, void *priv, char *netdrv_errbuf) { char errbuf[PCAP_ERRBUF_SIZE]; char *str; char filter_exp[255]; struct bpf_program fp; char errbuf_prep[NET_DRV_ERRBUF_SIZE]; char *intf_name = (char *) priv; /* Did we already load the library? */ if (libpcap_handle == NULL) { net_pcap_error(netdrv_errbuf, "net_pcap_init without handle"); return NULL; } /* Get the PCAP library name and version. */ strcpy(errbuf, f_pcap_lib_version()); str = strchr(errbuf, '('); if (str != NULL) *(str - 1) = '\0'; pcap_log("PCAP: initializing, %s\n", errbuf); /* Get the value of our capture interface. */ if ((intf_name[0] == '\0') || !strcmp(intf_name, "none")) { net_pcap_error(netdrv_errbuf, "No interface configured"); return NULL; } pcap_log("PCAP: interface: %s\n", intf_name); net_pcap_t *pcap = calloc(1, sizeof(net_pcap_t)); pcap->card = (netcard_t *) card; memcpy(pcap->mac_addr, mac_addr, sizeof(pcap->mac_addr)); if ((pcap->pcap = f_pcap_create(intf_name, errbuf)) == NULL) { snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, " Unable to open device: %s!\n", intf_name); net_pcap_error(netdrv_errbuf, errbuf_prep); free(pcap); return NULL; } if (f_pcap_setnonblock(pcap->pcap, 1, errbuf) != 0) pcap_log("PCAP: failed nonblock %s\n", errbuf); if (f_pcap_set_immediate_mode(pcap->pcap, 1) != 0) pcap_log("PCAP: error setting immediate mode\n"); if (f_pcap_set_promisc(pcap->pcap, 1) != 0) pcap_log("PCAP: error enabling promiscuous mode\n"); if (f_pcap_set_snaplen(pcap->pcap, NET_MAX_FRAME) != 0) pcap_log("PCAP: error setting snaplen\n"); if (f_pcap_activate(pcap->pcap) != 0) { snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, "%s", (char *)f_pcap_geterr(pcap->pcap)); net_pcap_error(netdrv_errbuf, errbuf_prep); f_pcap_close(pcap->pcap); free(pcap); return NULL; } /* Create a MAC address based packet filter. */ pcap_log("PCAP: installing filter for MAC=%02x:%02x:%02x:%02x:%02x:%02x\n", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); sprintf(filter_exp, "( ((ether broadcast) or (ether multicast) or (ether dst %02x:%02x:%02x:%02x:%02x:%02x)) and not (ether src %02x:%02x:%02x:%02x:%02x:%02x) )", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5], mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]); if (f_pcap_compile(pcap->pcap, &fp, filter_exp, 0, 0xffffffff) != -1) { if (f_pcap_setfilter(pcap->pcap, &fp) != 0) { snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, "Error installing filter (%s)\n", filter_exp); net_pcap_error(netdrv_errbuf, errbuf_prep); f_pcap_close(pcap->pcap); free(pcap); return NULL; } } else { snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, "Could not compile filter (%s) : %s!\n", filter_exp, (char *)f_pcap_geterr(pcap->pcap)); net_pcap_error(netdrv_errbuf, errbuf_prep); f_pcap_close(pcap->pcap); free(pcap); return NULL; } #ifdef _WIN32 pcap->pcap_queue = f_pcap_sendqueue_alloc(PCAP_PKT_BATCH * NET_MAX_FRAME); #endif for (int i = 0; i < PCAP_PKT_BATCH; i++) { pcap->pktv[i].data = calloc(1, NET_MAX_FRAME); } pcap->pkt.data = calloc(1, NET_MAX_FRAME); net_event_init(&pcap->tx_event); net_event_init(&pcap->stop_event); pcap->poll_tid = thread_create(net_pcap_thread, pcap); return pcap; } /* Close up shop. */ void net_pcap_close(void *priv) { if (!priv) return; net_pcap_t *pcap = (net_pcap_t *) priv; pcap_log("PCAP: closing.\n"); /* Tell the thread to terminate. */ net_event_set(&pcap->stop_event); /* Wait for the thread to finish. */ pcap_log("PCAP: waiting for thread to end...\n"); thread_wait(pcap->poll_tid); pcap_log("PCAP: thread ended\n"); for (int i = 0; i < PCAP_PKT_BATCH; i++) { free(pcap->pktv[i].data); } free(pcap->pkt.data); #ifdef _WIN32 f_pcap_sendqueue_destroy((void *) pcap->pcap_queue); #endif /* OK, now shut down Pcap itself. */ f_pcap_close(pcap->pcap); net_event_close(&pcap->tx_event); net_event_close(&pcap->stop_event); free(pcap); } const netdrv_t net_pcap_drv = { &net_pcap_in_available, &net_pcap_init, &net_pcap_close, NULL };