#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