* SUCH DAMAGE.
*/
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <config.h>
#include <poll.h>
-#include <ctype.h>
#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <sys/ioctl.h>
#define NETMAP_WITH_LIBS
#include <net/netmap_user.h>
#include "pcap-int.h"
#include "pcap-netmap.h"
-#if defined (linux)
-/* On FreeBSD we use IFF_PPROMISC which is in ifr_flagshigh.
- * remap to IFF_PROMISC on linux
- */
-#define IFF_PPROMISC IFF_PROMISC
-#endif /* linux */
+#ifndef __FreeBSD__
+ /*
+ * On FreeBSD we use IFF_PPROMISC which is in ifr_flagshigh.
+ * Remap to IFF_PROMISC on other platforms.
+ *
+ * XXX - DragonFly BSD?
+ */
+ #define IFF_PPROMISC IFF_PROMISC
+#endif /* __FreeBSD__ */
struct pcap_netmap {
struct nm_desc *d; /* pointer returned by nm_open() */
{
struct pcap_netmap *pn = p->priv;
- ps->ps_recv = pn->rx_pkts;
+ ps->ps_recv = (u_int)pn->rx_pkts;
ps->ps_drop = 0;
ps->ps_ifdrop = 0;
return 0;
const struct bpf_insn *pc = p->fcode.bf_insns;
++pn->rx_pkts;
- if (pc == NULL || bpf_filter(pc, buf, h->len, h->caplen))
+ if (pc == NULL || pcapint_filter(pc, buf, h->len, h->caplen))
pn->cb(pn->cb_arg, h, buf);
}
/* XXX need to check the NIOCTXSYNC/poll */
static int
-pcap_netmap_inject(pcap_t *p, const void *buf, size_t size)
+pcap_netmap_inject(pcap_t *p, const void *buf, int size)
{
struct pcap_netmap *pn = p->priv;
struct nm_desc *d = pn->d;
struct ifreq ifr;
int error, fd = d->fd;
-#ifdef linux
+#ifdef __linux__
fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0) {
fprintf(stderr, "Error: cannot get device control socket.\n");
return -1;
}
-#endif /* linux */
+#endif /* __linux__ */
bzero(&ifr, sizeof(ifr));
- strncpy(ifr.ifr_name, d->req.nr_name, sizeof(ifr.ifr_name));
+ /*
+ * ifreq.ifr_name and nmreq.nr_name have the same size and both
+ * contain a NUL-terminated string.
+ */
+ (void)pcapint_strlcpy(ifr.ifr_name, d->req.nr_name, sizeof(ifr.ifr_name));
switch (what) {
case SIOCSIFFLAGS:
- ifr.ifr_flags = *if_flags;
+ /*
+ * The flags we pass in are 32-bit and unsigned.
+ *
+ * On most if not all UN*Xes, ifr_flags is 16-bit and
+ * signed, and the result of assigning a longer
+ * unsigned value to a shorter signed value is
+ * implementation-defined (even if, in practice, it'll
+ * do what's intended on all platforms we support
+ * result of assigning a 32-bit unsigned value).
+ * So we mask out the upper 16 bits.
+ */
+ ifr.ifr_flags = *if_flags & 0xffff;
#ifdef __FreeBSD__
+ /*
+ * In FreeBSD, we need to set the high-order flags,
+ * as we're using IFF_PPROMISC, which is in those bits.
+ *
+ * XXX - DragonFly BSD?
+ */
ifr.ifr_flagshigh = *if_flags >> 16;
#endif /* __FreeBSD__ */
break;
if (!error) {
switch (what) {
case SIOCGIFFLAGS:
- *if_flags = ifr.ifr_flags;
+ /*
+ * The flags we return are 32-bit.
+ *
+ * On most if not all UN*Xes, ifr_flags is
+ * 16-bit and signed, and will get sign-
+ * extended, so that the upper 16 bits of
+ * those flags will be forced on. So we
+ * mask out the upper 16 bits of the
+ * sign-extended value.
+ */
+ *if_flags = ifr.ifr_flags & 0xffff;
#ifdef __FreeBSD__
+ /*
+ * In FreeBSD, we need to return the
+ * high-order flags, as we're using
+ * IFF_PPROMISC, which is in those bits.
+ *
+ * XXX - DragonFly BSD?
+ */
*if_flags |= (ifr.ifr_flagshigh << 16);
#endif /* __FreeBSD__ */
}
}
-#ifdef linux
+#ifdef __linux__
close(fd);
-#endif /* linux */
+#endif /* __linux__ */
return error ? -1 : 0;
}
}
}
nm_close(d);
- pcap_cleanup_live_common(p);
+ pcapint_cleanup_live_common(p);
}
pcap_netmap_activate(pcap_t *p)
{
struct pcap_netmap *pn = p->priv;
- struct nm_desc *d = nm_open(p->opt.source, NULL, 0, NULL);
+ struct nm_desc *d;
uint32_t if_flags = 0;
+ d = nm_open(p->opt.device, NULL, 0, NULL);
if (d == NULL) {
- snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
- "netmap open: cannot access %s: %s\n",
- p->opt.source, pcap_strerror(errno));
- pcap_cleanup_live_common(p);
+ pcapint_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+ errno, "netmap open: cannot access %s",
+ p->opt.device);
+ pcapint_cleanup_live_common(p);
return (PCAP_ERROR);
}
- if (0)
- fprintf(stderr, "%s device %s priv %p fd %d ports %d..%d\n",
- __FUNCTION__, p->opt.source, d, d->fd,
- d->first_rx_ring, d->last_rx_ring);
+#if 0
+ fprintf(stderr, "%s device %s priv %p fd %d ports %d..%d\n",
+ __func__, p->opt.device, d, d->fd,
+ d->first_rx_ring, d->last_rx_ring);
+#endif
pn->d = d;
p->fd = d->fd;
+
+ /*
+ * Turn a negative snapshot value (invalid), a snapshot value of
+ * 0 (unspecified), or a value bigger than the normal maximum
+ * value, into the maximum allowed value.
+ *
+ * If some application really *needs* a bigger snapshot
+ * length, we should just increase MAXIMUM_SNAPLEN.
+ */
+ if (p->snapshot <= 0 || p->snapshot > MAXIMUM_SNAPLEN)
+ p->snapshot = MAXIMUM_SNAPLEN;
+
if (p->opt.promisc && !(d->req.nr_ringid & NETMAP_SW_RING)) {
pcap_netmap_ioctl(p, SIOCGIFFLAGS, &if_flags); /* fetch flags */
if (!(if_flags & IFF_PPROMISC)) {
p->linktype = DLT_EN10MB;
p->selectable_fd = p->fd;
p->read_op = pcap_netmap_dispatch;
- p->inject_op = pcap_netmap_inject,
- p->setfilter_op = install_bpf_program;
+ p->inject_op = pcap_netmap_inject;
+ p->setfilter_op = pcapint_install_bpf_program;
p->setdirection_op = NULL;
p->set_datalink_op = NULL;
- p->getnonblock_op = pcap_getnonblock_fd;
- p->setnonblock_op = pcap_setnonblock_fd;
+ p->getnonblock_op = pcapint_getnonblock_fd;
+ p->setnonblock_op = pcapint_setnonblock_fd;
p->stats_op = pcap_netmap_stats;
p->cleanup_op = pcap_netmap_close;
*is_ours = (!strncmp(device, "netmap:", 7) || !strncmp(device, "vale", 4));
if (! *is_ours)
return NULL;
- p = pcap_create_common(ebuf, sizeof (struct pcap_netmap));
+ p = PCAP_CREATE_COMMON(ebuf, struct pcap_netmap);
if (p == NULL)
return (NULL);
p->activate_op = pcap_netmap_activate;
}
/*
- * XXX - is there a way to enumerate the netmap devices?
+ * The "device name" for netmap devices isn't a name for a device, it's
+ * an expression that indicates how the device should be set up, so
+ * there's no way to enumerate them.
*/
int
-pcap_netmap_findalldevs(pcap_if_list_t *devlistp, char *err_str)
+pcap_netmap_findalldevs(pcap_if_list_t *devlistp _U_, char *err_str _U_)
{
return 0;
}
-
projects / libpcap / blobdiff