--- libaitio/src/bpf.c	2013/06/24 09:22:41	1.1.2.1
+++ libaitio/src/bpf.c	2013/06/25 08:45:50	1.1.2.7
@@ -1,3 +1,263 @@
 #include "global.h"
 
 
+/*
+ * io_get1stiface() - Get first interface of host
+ *
+ * @szIface = interface string buffer
+ * @iflen = size of interface buffer
+ * return: -1 error or 0 ok
+ */
+int
+io_get1stiface(char *szIface, int iflen)
+{
+	struct ifaddrs *ifa;
+
+	if (!szIface || !iflen)
+		return -1;
+
+	getifaddrs(&ifa);
+	strlcpy(szIface, ifa->ifa_name, iflen);
+	freeifaddrs(ifa);
+	return 0;
+}
+
+/*
+ * io_etherClose() - Close BPF interface
+ *
+ * @eth = bpf handle
+ * @zcbuf = zero copy buffer, if BPF supports it and isn't NULL
+ * return: none
+ */
+void
+io_etherClose(int eth, void **zcbuf)
+{
+#ifdef __FreeBSD__
+	struct bpf_zbuf *zbuf = NULL;
+#endif
+
+	if (eth > STDERR_FILENO)
+		close(eth);
+
+	if (zcbuf && *zcbuf) {
+#ifdef __FreeBSD__
+		zbuf = *zcbuf;
+		munmap(zbuf->bz_bufb, zbuf->bz_buflen);
+		munmap(zbuf->bz_bufa, zbuf->bz_buflen);
+		e_free(*zcbuf);
+		*zcbuf = NULL;
+#endif
+	}
+}
+
+#ifdef __FreeBSD__
+static inline struct bpf_zbuf *
+allocZCbuf(u_int len)
+{
+	struct bpf_zbuf *zbuf = NULL;
+
+	zbuf = e_malloc(sizeof(struct bpf_zbuf));
+	if (!zbuf) {
+		io_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
+		return NULL;
+	} else
+		memset(zbuf, 0, sizeof(struct bpf_zbuf));
+
+	zbuf->bz_buflen = roundup(len, getpagesize());
+	zbuf->bz_bufa = mmap(NULL, zbuf->bz_buflen, PROT_READ | PROT_WRITE, MAP_ANON, -1, 0);
+	if (zbuf->bz_bufa == MAP_FAILED) {
+		LOGERR;
+		e_free(zbuf);
+		return NULL;
+	} else
+		memset(zbuf->bz_bufa, 0, zbuf->bz_buflen);
+	zbuf->bz_bufb = mmap(NULL, zbuf->bz_buflen, PROT_READ | PROT_WRITE, MAP_ANON, -1, 0);
+	if (zbuf->bz_bufb == MAP_FAILED) {
+		LOGERR;
+		munmap(zbuf->bz_bufa, zbuf->bz_buflen);
+		e_free(zbuf);
+		return NULL;
+	} else
+		memset(zbuf->bz_bufb, 0, zbuf->bz_buflen);
+
+	return zbuf;
+}
+#endif
+
+/*
+ * io_etherOpen() - Open BPF interface to device
+ *
+ * @csIface = interface name
+ * @flags = open flags
+ * @whdr = with complete headers
+ * @buflen = buffer length
+ * @zcbuf = zero copy buffer, if BPF supports it and isn't NULL
+ * return: -1 error or >-1 bpf handle
+ */
+int
+io_etherOpen(const char *csIface, int flags, int whdr, u_int *buflen, void **zcbuf)
+{
+	int n = 1, eth = -1;
+	register int i;
+	char szStr[STRSIZ];
+	struct ifreq ifr;
+
+	for (i = 0; i < BPF_DEV_MAX; i++) {
+		memset(szStr, 0, sizeof szStr);
+		snprintf(szStr, sizeof szStr, "/dev/bpf%d", i);
+		eth = open(szStr, flags);
+		if (eth > STDERR_FILENO)
+			break;
+	}
+	if (eth < 3) {
+		LOGERR;
+		return -1;
+	}
+
+	if (ioctl(eth, BIOCIMMEDIATE, &n) == -1) {
+		LOGERR;
+		close(eth);
+		return -1;
+	}
+	if (whdr && ioctl(eth, BIOCSHDRCMPLT, &n) == -1) {
+		LOGERR;
+		close(eth);
+		return -1;
+	}
+	if (buflen && *buflen) {
+		if (!zcbuf) {
+			if (ioctl(eth, BIOCSBLEN, buflen) == -1) {
+				LOGERR;
+				close(eth);
+				return -1;
+			}
+		} else {
+#ifdef __FreeBSD__
+			n = BPF_BUFMODE_ZBUF;
+			if (ioctl(eth, BIOCSETBUFMODE, &n) == -1) {
+				LOGERR;
+				close(eth);
+				return -1;
+			}
+			if (ioctl(eth, BIOCGETZMAX, &n) == -1) {
+				LOGERR;
+				close(eth);
+				return -1;
+			} else
+				*buflen = MIN(n, *buflen);
+			if (!(*zcbuf = allocZCbuf(*buflen))) {
+				close(eth);
+				return -1;
+			}
+			if (ioctl(eth, BIOCSETZBUF, (struct bpf_zbuf*) *zcbuf) == -1) {
+				LOGERR;
+				io_etherClose(eth, zcbuf);
+				return -1;
+			}
+#endif
+		}
+	}
+	if (csIface)
+		strlcpy(szStr, csIface, sizeof szStr);
+	else if (io_get1stiface(szStr, sizeof szStr) == -1) {
+		io_etherClose(eth, zcbuf);
+		return -1;
+	}
+	strlcpy(ifr.ifr_name, szStr, sizeof ifr.ifr_name);
+	if (ioctl(eth, BIOCSETIF, &ifr) == -1) {
+		LOGERR;
+		io_etherClose(eth, zcbuf);
+		return -1;
+	}
+
+	return eth;
+}
+
+/*
+ * io_etherSend() - Send packet to bpf
+ *
+ * @eth = bpf handle
+ * @buf = buffer
+ * @buflen = buffer length
+ * return: -1 error or !=-1 written bytes
+ */
+ssize_t
+io_etherSend(int eth, const void *buf, size_t buflen)
+{
+	ssize_t wlen = 0;
+
+	if (!buf || !buflen) {
+		io_SetErr(EINVAL, "invalid arguments");
+		return -1;
+	}
+
+	wlen = write(eth, buf, buflen);
+	if (wlen == -1)
+		LOGERR;
+	return wlen;
+}
+
+#ifdef __FreeBSD__
+static inline ssize_t
+nextZCbuf(void ** __restrict zcache, struct bpf_zbuf * __restrict zbuf, 
+		const void * __restrict buf)
+{
+	ssize_t rlen = -1;
+	struct bpf_zbuf_header *bzh;
+
+	if (!*zcache || *zcache == zbuf->bz_bufb) {
+		bzh = (struct bpf_zbuf_header *) zbuf->bz_bufa;
+		if (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen)) {
+			rlen = atomic_load_acq_int(&bzh->bzh_kernel_len);
+			*zcache = zbuf->bz_bufa;
+			if (buf)
+				buf = ((caddr_t) *zcache) + sizeof(struct bpf_zbuf_header);
+		}
+	} else if (*zcache == zbuf->bz_bufa) {
+		bzh = (struct bpf_zbuf_header *) zbuf->bz_bufb;
+		if (bzh->bzh_user_gen != atomic_load_acq_int(&bzh->bzh_kernel_gen)) {
+			rlen = atomic_load_acq_int(&bzh->bzh_kernel_len);
+			*zcache = zbuf->bz_bufb;
+			if (buf)
+				buf = ((caddr_t) *zcache) + sizeof(struct bpf_zbuf_header);
+		}
+	}
+
+	return rlen;
+}
+#endif
+
+/*
+ * io_etherRecv() - Receive packet from bpf
+ *
+ * @eth = bpf handle
+ * @buf = buffer
+ * @buflen = buffer length
+ * @zcbuf = zero copy buffer, if BPF supports it and isn't NULL
+ * return: -1 error or !=-1 readed bytes
+ */
+ssize_t
+io_etherRecv(int eth, void * __restrict buf, size_t buflen, void * __restrict zcbuf)
+{
+	ssize_t rlen = 0;
+	void **zcache = NULL;
+
+	if (!buf || !buflen) {
+		io_SetErr(EINVAL, "invalid arguments");
+		return -1;
+	}
+
+	if (!zcbuf) {
+		rlen = read(eth, buf, buflen);
+		if (rlen == -1)
+			LOGERR;
+	} else {
+#ifdef __FreeBSD__
+		rlen = nextZCbuf(zcache, (struct bpf_zbuf*) zcbuf, buf);
+#else
+		io_SetErr(ENOTSUP, "bpf zero copy buffer mode is not supported");
+#endif
+	}
+
+	return rlen;
+}