627 lines
15 KiB
C
627 lines
15 KiB
C
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: pcap-snf.c,v 1.6 2019/10/01 16:02:12 christos Exp $");
|
|
|
|
/* $NetBSD: pcap-snf.c,v 1.6 2019/10/01 16:02:12 christos Exp $ */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#ifndef _WIN32
|
|
#include <sys/param.h>
|
|
#endif /* !_WIN32 */
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include <ctype.h>
|
|
#ifndef _WIN32
|
|
#include <netinet/in.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#endif /* !_WIN32 */
|
|
|
|
#include <snf.h>
|
|
#if SNF_VERSION_API >= 0x0003
|
|
#define SNF_HAVE_INJECT_API
|
|
#endif
|
|
|
|
#include "pcap-int.h"
|
|
#include "pcap-snf.h"
|
|
|
|
/*
|
|
* Private data for capturing on SNF devices.
|
|
*/
|
|
struct pcap_snf {
|
|
snf_handle_t snf_handle; /* opaque device handle */
|
|
snf_ring_t snf_ring; /* opaque device ring handle */
|
|
#ifdef SNF_HAVE_INJECT_API
|
|
snf_inject_t snf_inj; /* inject handle, if inject is used */
|
|
#endif
|
|
int snf_timeout;
|
|
int snf_boardnum;
|
|
};
|
|
|
|
static int
|
|
snf_set_datalink(pcap_t *p, int dlt)
|
|
{
|
|
p->linktype = dlt;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
snf_pcap_stats(pcap_t *p, struct pcap_stat *ps)
|
|
{
|
|
struct snf_ring_stats stats;
|
|
struct pcap_snf *snfps = p->priv;
|
|
int rc;
|
|
|
|
if ((rc = snf_ring_getstats(snfps->snf_ring, &stats))) {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
|
|
rc, "snf_get_stats");
|
|
return -1;
|
|
}
|
|
ps->ps_recv = stats.ring_pkt_recv + stats.ring_pkt_overflow;
|
|
ps->ps_drop = stats.ring_pkt_overflow;
|
|
ps->ps_ifdrop = stats.nic_pkt_overflow + stats.nic_pkt_bad;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
snf_platform_cleanup(pcap_t *p)
|
|
{
|
|
struct pcap_snf *ps = p->priv;
|
|
|
|
#ifdef SNF_HAVE_INJECT_API
|
|
if (ps->snf_inj)
|
|
snf_inject_close(ps->snf_inj);
|
|
#endif
|
|
snf_ring_close(ps->snf_ring);
|
|
snf_close(ps->snf_handle);
|
|
pcap_cleanup_live_common(p);
|
|
}
|
|
|
|
static int
|
|
snf_getnonblock(pcap_t *p)
|
|
{
|
|
struct pcap_snf *ps = p->priv;
|
|
|
|
return (ps->snf_timeout == 0);
|
|
}
|
|
|
|
static int
|
|
snf_setnonblock(pcap_t *p, int nonblock)
|
|
{
|
|
struct pcap_snf *ps = p->priv;
|
|
|
|
if (nonblock)
|
|
ps->snf_timeout = 0;
|
|
else {
|
|
if (p->opt.timeout <= 0)
|
|
ps->snf_timeout = -1; /* forever */
|
|
else
|
|
ps->snf_timeout = p->opt.timeout;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
#define _NSEC_PER_SEC 1000000000
|
|
|
|
static inline
|
|
struct timeval
|
|
snf_timestamp_to_timeval(const int64_t ts_nanosec, const int tstamp_precision)
|
|
{
|
|
struct timeval tv;
|
|
long tv_nsec;
|
|
const static struct timeval zero_timeval;
|
|
|
|
if (ts_nanosec == 0)
|
|
return zero_timeval;
|
|
|
|
tv.tv_sec = ts_nanosec / _NSEC_PER_SEC;
|
|
tv_nsec = (ts_nanosec % _NSEC_PER_SEC);
|
|
|
|
/* libpcap expects tv_usec to be nanos if using nanosecond precision. */
|
|
if (tstamp_precision == PCAP_TSTAMP_PRECISION_NANO)
|
|
tv.tv_usec = tv_nsec;
|
|
else
|
|
tv.tv_usec = tv_nsec / 1000;
|
|
|
|
return tv;
|
|
}
|
|
|
|
static int
|
|
snf_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
|
|
{
|
|
struct pcap_snf *ps = p->priv;
|
|
struct pcap_pkthdr hdr;
|
|
int i, flags, err, caplen, n;
|
|
struct snf_recv_req req;
|
|
int nonblock, timeout;
|
|
|
|
if (!p)
|
|
return -1;
|
|
|
|
n = 0;
|
|
timeout = ps->snf_timeout;
|
|
while (n < cnt || PACKET_COUNT_IS_UNLIMITED(cnt)) {
|
|
/*
|
|
* Has "pcap_breakloop()" been called?
|
|
*/
|
|
if (p->break_loop) {
|
|
if (n == 0) {
|
|
p->break_loop = 0;
|
|
return (-2);
|
|
} else {
|
|
return (n);
|
|
}
|
|
}
|
|
|
|
err = snf_ring_recv(ps->snf_ring, timeout, &req);
|
|
|
|
if (err) {
|
|
if (err == EBUSY || err == EAGAIN) {
|
|
return (n);
|
|
}
|
|
else if (err == EINTR) {
|
|
timeout = 0;
|
|
continue;
|
|
}
|
|
else {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf,
|
|
PCAP_ERRBUF_SIZE, err, "snf_read");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
caplen = req.length;
|
|
if (caplen > p->snapshot)
|
|
caplen = p->snapshot;
|
|
|
|
if ((p->fcode.bf_insns == NULL) ||
|
|
bpf_filter(p->fcode.bf_insns, req.pkt_addr, req.length, caplen)) {
|
|
hdr.ts = snf_timestamp_to_timeval(req.timestamp, p->opt.tstamp_precision);
|
|
hdr.caplen = caplen;
|
|
hdr.len = req.length;
|
|
callback(user, &hdr, req.pkt_addr);
|
|
n++;
|
|
}
|
|
|
|
/* After one successful packet is received, we won't block
|
|
* again for that timeout. */
|
|
if (timeout != 0)
|
|
timeout = 0;
|
|
}
|
|
return (n);
|
|
}
|
|
|
|
static int
|
|
snf_setfilter(pcap_t *p, struct bpf_program *fp)
|
|
{
|
|
if (!p)
|
|
return -1;
|
|
if (!fp) {
|
|
strncpy(p->errbuf, "setfilter: No filter specified",
|
|
sizeof(p->errbuf));
|
|
return -1;
|
|
}
|
|
|
|
/* Make our private copy of the filter */
|
|
|
|
if (install_bpf_program(p, fp) < 0)
|
|
return -1;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
snf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
|
|
{
|
|
#ifdef SNF_HAVE_INJECT_API
|
|
struct pcap_snf *ps = p->priv;
|
|
int rc;
|
|
if (ps->snf_inj == NULL) {
|
|
rc = snf_inject_open(ps->snf_boardnum, 0, &ps->snf_inj);
|
|
if (rc) {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
|
|
rc, "snf_inject_open");
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
rc = snf_inject_send(ps->snf_inj, -1, 0, buf, size);
|
|
if (!rc) {
|
|
return (size);
|
|
}
|
|
else {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
|
|
rc, "snf_inject_send");
|
|
return (-1);
|
|
}
|
|
#else
|
|
pcap_strlcpy(p->errbuf, "Sending packets isn't supported with this snf version",
|
|
PCAP_ERRBUF_SIZE);
|
|
return (-1);
|
|
#endif
|
|
}
|
|
|
|
static int
|
|
snf_activate(pcap_t* p)
|
|
{
|
|
struct pcap_snf *ps = p->priv;
|
|
char *device = p->opt.device;
|
|
const char *nr = NULL;
|
|
int err;
|
|
int flags = -1, ring_id = -1;
|
|
|
|
if (device == NULL) {
|
|
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "device is NULL");
|
|
return -1;
|
|
}
|
|
|
|
/* In Libpcap, we set pshared by default if NUM_RINGS is set to > 1.
|
|
* Since libpcap isn't thread-safe */
|
|
if ((nr = getenv("SNF_FLAGS")) && *nr)
|
|
flags = strtol(nr, NULL, 0);
|
|
else if ((nr = getenv("SNF_NUM_RINGS")) && *nr && atoi(nr) > 1)
|
|
flags = SNF_F_PSHARED;
|
|
else
|
|
nr = NULL;
|
|
|
|
|
|
/* Allow pcap_set_buffer_size() to set dataring_size.
|
|
* Default is zero which allows setting from env SNF_DATARING_SIZE.
|
|
* pcap_set_buffer_size() is in bytes while snf_open() accepts values
|
|
* between 0 and 1048576 in Megabytes. Values in this range are
|
|
* mapped to 1MB.
|
|
*/
|
|
err = snf_open(ps->snf_boardnum,
|
|
0, /* let SNF API parse SNF_NUM_RINGS, if set */
|
|
NULL, /* default RSS, or use SNF_RSS_FLAGS env */
|
|
(p->opt.buffer_size > 0 && p->opt.buffer_size < 1048576) ? 1048576 : p->opt.buffer_size, /* default to SNF_DATARING_SIZE from env */
|
|
flags, /* may want pshared */
|
|
&ps->snf_handle);
|
|
if (err != 0) {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
|
|
err, "snf_open failed");
|
|
return -1;
|
|
}
|
|
|
|
if ((nr = getenv("SNF_PCAP_RING_ID")) && *nr) {
|
|
ring_id = (int) strtol(nr, NULL, 0);
|
|
}
|
|
err = snf_ring_open_id(ps->snf_handle, ring_id, &ps->snf_ring);
|
|
if (err != 0) {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
|
|
err, "snf_ring_open_id(ring=%d) failed", ring_id);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* 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.timeout <= 0)
|
|
ps->snf_timeout = -1;
|
|
else
|
|
ps->snf_timeout = p->opt.timeout;
|
|
|
|
err = snf_start(ps->snf_handle);
|
|
if (err != 0) {
|
|
pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
|
|
err, "snf_start failed");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* "select()" and "poll()" don't work on snf descriptors.
|
|
*/
|
|
#ifndef _WIN32
|
|
p->selectable_fd = -1;
|
|
#endif /* !_WIN32 */
|
|
p->linktype = DLT_EN10MB;
|
|
p->read_op = snf_read;
|
|
p->inject_op = snf_inject;
|
|
p->setfilter_op = snf_setfilter;
|
|
p->setdirection_op = NULL; /* Not implemented.*/
|
|
p->set_datalink_op = snf_set_datalink;
|
|
p->getnonblock_op = snf_getnonblock;
|
|
p->setnonblock_op = snf_setnonblock;
|
|
p->stats_op = snf_pcap_stats;
|
|
p->cleanup_op = snf_platform_cleanup;
|
|
#ifdef SNF_HAVE_INJECT_API
|
|
ps->snf_inj = NULL;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#define MAX_DESC_LENGTH 128
|
|
int
|
|
snf_findalldevs(pcap_if_list_t *devlistp, char *errbuf)
|
|
{
|
|
pcap_if_t *dev;
|
|
#ifdef _WIN32
|
|
struct sockaddr_in addr;
|
|
#endif
|
|
struct snf_ifaddrs *ifaddrs, *ifa;
|
|
char name[MAX_DESC_LENGTH];
|
|
char desc[MAX_DESC_LENGTH];
|
|
int ret, allports = 0, merge = 0;
|
|
const char *nr = NULL;
|
|
|
|
if (snf_init(SNF_VERSION_API)) {
|
|
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
|
"snf_getifaddrs: snf_init failed");
|
|
return (-1);
|
|
}
|
|
|
|
if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL)
|
|
{
|
|
pcap_fmt_errmsg_for_errno(errbuf, PCAP_ERRBUF_SIZE,
|
|
errno, "snf_getifaddrs");
|
|
return (-1);
|
|
}
|
|
if ((nr = getenv("SNF_FLAGS")) && *nr) {
|
|
errno = 0;
|
|
merge = strtol(nr, NULL, 0);
|
|
if (errno) {
|
|
(void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
|
"snf_getifaddrs: SNF_FLAGS is not a valid number");
|
|
return (-1);
|
|
}
|
|
merge = merge & SNF_F_AGGREGATE_PORTMASK;
|
|
}
|
|
|
|
for (ifa = ifaddrs; ifa != NULL; ifa = ifa->snf_ifa_next) {
|
|
/*
|
|
* Myricom SNF adapter ports may appear as regular
|
|
* network interfaces, which would already have been
|
|
* added to the list of adapters by pcap_platform_finddevs()
|
|
* if this isn't an SNF-only version of libpcap.
|
|
*
|
|
* Our create routine intercepts pcap_create() calls for
|
|
* those interfaces and arranges that they will be
|
|
* opened using the SNF API instead.
|
|
*
|
|
* So if we already have an entry for the device, we
|
|
* don't add an additional entry for it, we just
|
|
* update the description for it, if any, to indicate
|
|
* which snfN device it is. Otherwise, we add an entry
|
|
* for it.
|
|
*
|
|
* In either case, if SNF_F_AGGREGATE_PORTMASK is set
|
|
* in SNF_FLAGS, we add this port to the bitmask
|
|
* of ports, which we use to generate a device
|
|
* we can use to capture on all ports.
|
|
*
|
|
* Generate the description string. If port aggregation
|
|
* is set, use 2^{port number} as the unit number,
|
|
* rather than {port number}.
|
|
*
|
|
* XXX - do entries in this list have IP addresses for
|
|
* the port? If so, should we add them to the
|
|
* entry for the device, if they're not already in the
|
|
* list of IP addresses for the device?
|
|
*/
|
|
(void)pcap_snprintf(desc,MAX_DESC_LENGTH,"Myricom %ssnf%d",
|
|
merge ? "Merge Bitmask Port " : "",
|
|
merge ? 1 << ifa->snf_ifa_portnum : ifa->snf_ifa_portnum);
|
|
/*
|
|
* Add the port to the bitmask.
|
|
*/
|
|
if (merge)
|
|
allports |= 1 << ifa->snf_ifa_portnum;
|
|
/*
|
|
* See if there's already an entry for the device
|
|
* with the name ifa->snf_ifa_name.
|
|
*/
|
|
dev = find_dev(devlistp, ifa->snf_ifa_name);
|
|
if (dev != NULL) {
|
|
/*
|
|
* Yes. Update its description.
|
|
*/
|
|
char *desc_str;
|
|
|
|
desc_str = strdup(desc);
|
|
if (desc_str == NULL) {
|
|
pcap_fmt_errmsg_for_errno(errbuf,
|
|
PCAP_ERRBUF_SIZE, errno,
|
|
"snf_findalldevs strdup");
|
|
return -1;
|
|
}
|
|
free(dev->description);
|
|
dev->description = desc_str;
|
|
} else {
|
|
/*
|
|
* No. Add an entry for it.
|
|
*
|
|
* XXX - is there a notion of "up" or "running",
|
|
* and can we determine whether something's
|
|
* plugged into the adapter and set
|
|
* PCAP_IF_CONNECTION_STATUS_CONNECTED or
|
|
* PCAP_IF_CONNECTION_STATUS_DISCONNECTED?
|
|
*/
|
|
dev = add_dev(devlistp, ifa->snf_ifa_name, 0, desc,
|
|
errbuf);
|
|
if (dev == NULL)
|
|
return -1;
|
|
#ifdef _WIN32
|
|
/*
|
|
* On Windows, fill in IP# from device name
|
|
*/
|
|
ret = inet_pton(AF_INET, dev->name, &addr.sin_addr);
|
|
if (ret == 1) {
|
|
/*
|
|
* Successful conversion of device name
|
|
* to IPv4 address.
|
|
*/
|
|
addr.sin_family = AF_INET;
|
|
if (add_addr_to_dev(dev, &addr, sizeof(addr),
|
|
NULL, 0, NULL, 0, NULL, 0, errbuf) == -1)
|
|
return -1;
|
|
} else if (ret == -1) {
|
|
/*
|
|
* Error.
|
|
*/
|
|
pcap_fmt_errmsg_for_errno(errbuf,
|
|
PCAP_ERRBUF_SIZE, errno,
|
|
"sinf_findalldevs inet_pton");
|
|
return -1;
|
|
}
|
|
#endif _WIN32
|
|
}
|
|
}
|
|
snf_freeifaddrs(ifaddrs);
|
|
/*
|
|
* Create a snfX entry if port aggregation is enabled
|
|
*/
|
|
if (merge) {
|
|
/*
|
|
* Add a new entry with all ports bitmask
|
|
*/
|
|
(void)pcap_snprintf(name,MAX_DESC_LENGTH,"snf%d",allports);
|
|
(void)pcap_snprintf(desc,MAX_DESC_LENGTH,"Myricom Merge Bitmask All Ports snf%d",
|
|
allports);
|
|
/*
|
|
* XXX - is there any notion of "up" and "running" that
|
|
* would apply to this device, given that it handles
|
|
* multiple ports?
|
|
*
|
|
* Presumably, there's no notion of "connected" vs.
|
|
* "disconnected", as "is this plugged into a network?"
|
|
* would be a per-port property.
|
|
*/
|
|
if (add_dev(devlistp, name,
|
|
PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE, desc,
|
|
errbuf) == NULL)
|
|
return (-1);
|
|
/*
|
|
* XXX - should we give it a list of addresses with all
|
|
* the addresses for all the ports?
|
|
*/
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
pcap_t *
|
|
snf_create(const char *device, char *ebuf, int *is_ours)
|
|
{
|
|
pcap_t *p;
|
|
int boardnum = -1;
|
|
struct snf_ifaddrs *ifaddrs, *ifa;
|
|
size_t devlen;
|
|
struct pcap_snf *ps;
|
|
|
|
if (snf_init(SNF_VERSION_API)) {
|
|
/* Can't initialize the API, so no SNF devices */
|
|
*is_ours = 0;
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Match a given interface name to our list of interface names, from
|
|
* which we can obtain the intended board number
|
|
*/
|
|
if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL) {
|
|
/* Can't get SNF addresses */
|
|
*is_ours = 0;
|
|
return NULL;
|
|
}
|
|
devlen = strlen(device) + 1;
|
|
ifa = ifaddrs;
|
|
while (ifa) {
|
|
if (strncmp(device, ifa->snf_ifa_name, devlen) == 0) {
|
|
boardnum = ifa->snf_ifa_boardnum;
|
|
break;
|
|
}
|
|
ifa = ifa->snf_ifa_next;
|
|
}
|
|
snf_freeifaddrs(ifaddrs);
|
|
|
|
if (ifa == NULL) {
|
|
/*
|
|
* If we can't find the device by name, support the name "snfX"
|
|
* and "snf10gX" where X is the board number.
|
|
*/
|
|
if (sscanf(device, "snf10g%d", &boardnum) != 1 &&
|
|
sscanf(device, "snf%d", &boardnum) != 1) {
|
|
/* Nope, not a supported name */
|
|
*is_ours = 0;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* OK, it's probably ours. */
|
|
*is_ours = 1;
|
|
|
|
p = pcap_create_common(ebuf, sizeof (struct pcap_snf));
|
|
if (p == NULL)
|
|
return NULL;
|
|
ps = p->priv;
|
|
|
|
/*
|
|
* We support microsecond and nanosecond time stamps.
|
|
*/
|
|
p->tstamp_precision_count = 2;
|
|
p->tstamp_precision_list = malloc(2 * sizeof(u_int));
|
|
if (p->tstamp_precision_list == NULL) {
|
|
pcap_fmt_errmsg_for_errno(ebuf, PCAP_ERRBUF_SIZE, errno,
|
|
"malloc");
|
|
pcap_close(p);
|
|
return NULL;
|
|
}
|
|
p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
|
|
p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
|
|
|
|
p->activate_op = snf_activate;
|
|
ps->snf_boardnum = boardnum;
|
|
return p;
|
|
}
|
|
|
|
#ifdef SNF_ONLY
|
|
/*
|
|
* This libpcap build supports only SNF cards, not regular network
|
|
* interfaces..
|
|
*/
|
|
|
|
/*
|
|
* There are no regular interfaces, just SNF interfaces.
|
|
*/
|
|
int
|
|
pcap_platform_finddevs(pcap_if_list_t *devlistp, char *errbuf)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Attempts to open a regular interface fail.
|
|
*/
|
|
pcap_t *
|
|
pcap_create_interface(const char *device, char *errbuf)
|
|
{
|
|
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
|
|
"This version of libpcap only supports SNF cards");
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Libpcap version string.
|
|
*/
|
|
const char *
|
|
pcap_lib_version(void)
|
|
{
|
|
return (PCAP_VERSION_STRING " (SNF-only)");
|
|
}
|
|
#endif
|