0001-pdump-add-cmdline-packet-filters-for-dpdk-pdump-tool.patch

From a152d34e729c5597ec8eebc6ba46a644e87a810f Mon Sep 17 00:00:00 2001
From: ywc689 <ywc689@163.com>
Date: Fri, 13 Dec 2024 17:06:14 +0800
Subject: [PATCH 1/6] pdump: add cmdline packet filters for dpdk-pdump tool

Signed-off-by: ywc689 <ywc689@163.com>
---
 app/pdump/main.c      | 171 ++++++++++++++++++++++++++++++++++++++--
 lib/pdump/rte_pdump.c | 176 ++++++++++++++++++++++++++++++++++++++----
 lib/pdump/rte_pdump.h |  39 ++++++++--
 3 files changed, 358 insertions(+), 28 deletions(-)

diff --git a/app/pdump/main.c b/app/pdump/main.c
index fa85859..6b35a6c 100644
--- a/app/pdump/main.c
+++ b/app/pdump/main.c
@@ -27,6 +27,7 @@
 #include <rte_ring.h>
 #include <rte_string_fns.h>
 #include <rte_pdump.h>
+#include <rte_malloc.h>
 
 #define CMD_LINE_OPT_PDUMP "pdump"
 #define CMD_LINE_OPT_PDUMP_NUM 256
@@ -42,6 +43,14 @@
 #define PDUMP_MSIZE_ARG "mbuf-size"
 #define PDUMP_NUM_MBUFS_ARG "total-num-mbufs"
 
+#define PDUMP_HOST_ARG "host"
+#define PDUMP_SRC_ARG "src-host"
+#define PDUMP_DST_ARG "dst-host"
+#define PDUMP_PROTO_PORT_ARG "proto-port"
+#define PDUMP_SPORT_ARG "src-port"
+#define PDUMP_DPORT_ARG "dst-port"
+#define PDUMP_PROTO_ARG "proto"
+
 #define VDEV_NAME_FMT "net_pcap_%s_%d"
 #define VDEV_PCAP_ARGS_FMT "tx_pcap=%s"
 #define VDEV_IFACE_ARGS_FMT "tx_iface=%s"
@@ -97,6 +106,13 @@ static const char * const valid_pdump_arguments[] = {
 	PDUMP_RING_SIZE_ARG,
 	PDUMP_MSIZE_ARG,
 	PDUMP_NUM_MBUFS_ARG,
+	PDUMP_HOST_ARG,
+	PDUMP_SRC_ARG,
+	PDUMP_DST_ARG,
+	PDUMP_PROTO_PORT_ARG,
+	PDUMP_SPORT_ARG,
+	PDUMP_DPORT_ARG,
+	PDUMP_PROTO_ARG,
 	NULL
 };
 
@@ -131,6 +147,9 @@ struct __rte_cache_aligned pdump_tuples {
 	enum pcap_stream tx_vdev_stream_type;
 	bool single_pdump_dev;
 
+	/* cmdline packet filter */
+	struct pdump_filter *filter0;
+
 	/* stats */
 	struct pdump_stats stats;
 };
@@ -158,6 +177,11 @@ pdump_usage(const char *prgname)
 			"(queue=<queue_id>),"
 			"(rx-dev=<iface or pcap file> |"
 			" tx-dev=<iface or pcap file>,"
+			"[host=<ipaddress> | src-host=<source ip address> |"
+			"dst-host=<destination ip address>],"
+			"[proto=<protocol type>support:tcp/udp/icmp/icmp6],"
+			"[proto-port=<protocol port> |src-port=<source protocol port> |"
+			"dst-port=<destination protocol port>],"
 			"[ring-size=<ring size>default:16384],"
 			"[mbuf-size=<mbuf data size>default:2176],"
 			"[total-num-mbufs=<number of mbufs>default:65535]'\n",
@@ -246,6 +270,66 @@ parse_uint_value(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+parse_host(const char *key __rte_unused, const char *value, void *extra_args)
+{
+	struct pdump_tuples *pt = extra_args;
+	struct in_addr	inaddr;
+	struct in6_addr	inaddr6;
+	union  addr		addr;
+	int				af = 0;
+
+	if (inet_pton(AF_INET6, value, &inaddr6) > 0) {
+		af = AF_INET6;
+		addr.in6 = inaddr6;
+	} else if (inet_pton(AF_INET, value, &inaddr) > 0){
+		af = AF_INET;
+		addr.in = inaddr;
+	} else {
+		printf("IP address invaled\n");
+		return -EINVAL;
+	}
+
+	if (pt->filter0 && pt->filter0->af != 0 && af != pt->filter0->af) {
+		printf("IPv4 and IPv6 conflict\n");
+		return -EINVAL;
+	} else {
+		pt->filter0->af = af;
+	}
+
+	if (!strcmp(key, PDUMP_HOST_ARG)) {
+		rte_memcpy(&pt->filter0->host_addr, &addr, sizeof(addr));
+	} else if (!strcmp(key, PDUMP_SRC_ARG)) {
+		rte_memcpy(&pt->filter0->s_addr, &addr, sizeof(addr));
+	} else if (!strcmp(key, PDUMP_DST_ARG)) {
+		rte_memcpy(&pt->filter0->d_addr, &addr, sizeof(addr));
+	}
+
+	return 0;
+}
+
+static int
+parse_proto(const char *key __rte_unused, const char *value, void *extra_args)
+{
+	struct pdump_tuples *pt = extra_args;
+
+	if (!strcmp(value, "tcp")) {
+		pt->filter0->proto = IPPROTO_TCP;
+	} else if (!strcmp(value, "udp")) {
+		pt->filter0->proto = IPPROTO_UDP;
+	} else if (!strcmp(value, "icmp6")) {
+		pt->filter0->proto = IPPROTO_ICMPV6;
+	} else if (!strcmp(value, "icmp")) {
+		pt->filter0->proto = IPPROTO_ICMP;
+	} else {
+		printf("invalid value:\"%s\" for key:\"%s\", "
+			"value must be tcp/udp/icmp/icmp6\n", value, key);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 static int
 parse_pdump(const char *optarg)
 {
@@ -373,6 +457,75 @@ parse_pdump(const char *optarg)
 	} else
 		pt->total_num_mbufs = MBUFS_PER_POOL;
 
+	/* filter parsing and validation */
+	pt->filter0 = rte_zmalloc("pdump_filter",
+			sizeof(struct pdump_filter), 0);
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_HOST_ARG);
+	if (cnt1 == 1) {
+		ret = rte_kvargs_process(kvlist, PDUMP_HOST_ARG,
+				&parse_host, pt);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_SRC_ARG);
+	if (cnt1 == 1) {
+		ret = rte_kvargs_process(kvlist, PDUMP_SRC_ARG,
+				&parse_host, pt);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_DST_ARG);
+	if (cnt1 == 1) {
+		ret = rte_kvargs_process(kvlist, PDUMP_DST_ARG,
+				&parse_host, pt);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_PROTO_PORT_ARG);
+	if (cnt1 == 1) {
+		v.min = 1;
+		v.max = UINT16_MAX;
+		ret = rte_kvargs_process(kvlist, PDUMP_PROTO_PORT_ARG,
+				&parse_uint_value, &v);
+		if (ret < 0)
+			goto free_kvlist;
+		pt->filter0->proto_port = (uint16_t) v.val;
+	}
+
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_SPORT_ARG);
+	if (cnt1 == 1) {
+		v.min = 1;
+		v.max = UINT16_MAX;
+		ret = rte_kvargs_process(kvlist, PDUMP_SPORT_ARG,
+				&parse_uint_value, &v);
+		if (ret < 0)
+			goto free_kvlist;
+		pt->filter0->s_port = (uint16_t) v.val;
+	}
+
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_DPORT_ARG);
+	if (cnt1 == 1) {
+		v.min = 1;
+		v.max = UINT16_MAX;
+		ret = rte_kvargs_process(kvlist, PDUMP_DPORT_ARG,
+				&parse_uint_value, &v);
+		if (ret < 0)
+			goto free_kvlist;
+		pt->filter0->d_port = (uint16_t) v.val;
+	}
+
+	cnt1 = rte_kvargs_count(kvlist, PDUMP_PROTO_ARG);
+	if (cnt1 == 1) {
+		ret = rte_kvargs_process(kvlist, PDUMP_PROTO_ARG,
+				&parse_proto, pt);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
 	num_tuples++;
 
 free_kvlist:
@@ -511,6 +664,8 @@ cleanup_rings(void)
 		rte_ring_free(pt->rx_ring);
 		rte_ring_free(pt->tx_ring);
 		rte_mempool_free(pt->mp);
+		if (pt->filter0)
+			rte_free(pt->filter0);
 	}
 }
 
@@ -831,20 +986,20 @@ enable_pdump(void)
 						pt->queue,
 						RTE_PDUMP_FLAG_RX,
 						pt->rx_ring,
-						pt->mp, NULL);
+						pt->mp, pt->filter0);
 				ret1 = rte_pdump_enable_by_deviceid(
 						pt->device_id,
 						pt->queue,
 						RTE_PDUMP_FLAG_TX,
 						pt->tx_ring,
-						pt->mp, NULL);
+						pt->mp, pt->filter0);
 			} else if (pt->dump_by_type == PORT_ID) {
 				ret = rte_pdump_enable(pt->port, pt->queue,
 						RTE_PDUMP_FLAG_RX,
-						pt->rx_ring, pt->mp, NULL);
+						pt->rx_ring, pt->mp, pt->filter0);
 				ret1 = rte_pdump_enable(pt->port, pt->queue,
 						RTE_PDUMP_FLAG_TX,
-						pt->tx_ring, pt->mp, NULL);
+						pt->tx_ring, pt->mp, pt->filter0);
 			}
 		} else if (pt->dir == RTE_PDUMP_FLAG_RX) {
 			if (pt->dump_by_type == DEVICE_ID)
@@ -852,22 +1007,22 @@ enable_pdump(void)
 						pt->device_id,
 						pt->queue,
 						pt->dir, pt->rx_ring,
-						pt->mp, NULL);
+						pt->mp, pt->filter0);
 			else if (pt->dump_by_type == PORT_ID)
 				ret = rte_pdump_enable(pt->port, pt->queue,
 						pt->dir,
-						pt->rx_ring, pt->mp, NULL);
+						pt->rx_ring, pt->mp, pt->filter0);
 		} else if (pt->dir == RTE_PDUMP_FLAG_TX) {
 			if (pt->dump_by_type == DEVICE_ID)
 				ret = rte_pdump_enable_by_deviceid(
 						pt->device_id,
 						pt->queue,
 						pt->dir,
-						pt->tx_ring, pt->mp, NULL);
+						pt->tx_ring, pt->mp, pt->filter0);
 			else if (pt->dump_by_type == PORT_ID)
 				ret = rte_pdump_enable(pt->port, pt->queue,
 						pt->dir,
-						pt->tx_ring, pt->mp, NULL);
+						pt->tx_ring, pt->mp, pt->filter0);
 		}
 		if (ret < 0 || ret1 < 0) {
 			cleanup_pdump_resources();
diff --git a/lib/pdump/rte_pdump.c b/lib/pdump/rte_pdump.c
index 679c3dd..f9b8a3e 100644
--- a/lib/pdump/rte_pdump.c
+++ b/lib/pdump/rte_pdump.c
@@ -12,6 +12,10 @@
 #include <rte_errno.h>
 #include <rte_string_fns.h>
 #include <rte_pcapng.h>
+#include <rte_arp.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+#include <rte_byteorder.h>
 
 #include "rte_pdump.h"
 
@@ -43,9 +47,12 @@ struct pdump_request {
 	uint16_t queue;
 	struct rte_ring *ring;
 	struct rte_mempool *mp;
-
+	/* cmdline packet filterr */
+	const struct pdump_filter *filter0;
+	/* eBpf packet filter */
 	const struct rte_bpf_prm *prm;
 	uint32_t snaplen;
+
 };
 
 struct pdump_response {
@@ -58,12 +65,139 @@ static struct pdump_rxtx_cbs {
 	struct rte_ring *ring;
 	struct rte_mempool *mp;
 	const struct rte_eth_rxtx_callback *cb;
-	const struct rte_bpf *filter;
+	const struct pdump_filter *filter0;			/* cmdline packet filterr */
+	const struct rte_bpf *filter;   /* eBpf packet filter */
 	enum pdump_version ver;
 	uint32_t snaplen;
 } rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
 tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
 
+static int
+inet_addr_equal(int af, const union addr *a1,
+		const union addr *a2)
+{
+	switch (af) {
+	case AF_INET:
+		return a1->in.s_addr == a2->in.s_addr;
+	case AF_INET6:
+		return memcmp(a1->in6.s6_addr, a2->in6.s6_addr, 16) == 0;
+	default:
+		return memcmp(a1, a2, sizeof(union addr)) == 0;
+	}
+}
+
+static int
+inet_is_addr_any(int af, const union addr *addr)
+{
+	switch (af) {
+	case AF_INET:
+		return addr->in.s_addr == htonl(INADDR_ANY);
+	case AF_INET6:
+		return IN6_ARE_ADDR_EQUAL(&addr->in6, &in6addr_any);
+	default:
+		return -1;
+	}
+
+	return -1;
+}
+static int
+pdump_filter(struct rte_mbuf *m, const struct pdump_filter *filter0)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct vlan_eth_hdr *vlan_eth_hdr;
+	union addr s_addr, d_addr;
+	int prepend = 0;
+	uint16_t type = 0;
+	uint16_t iph_len = 0;
+	uint8_t proto = 0;
+
+	int af;
+
+	if (filter0->af == 0 && filter0->s_port == 0 &&
+			filter0->d_port == 0 && filter0->proto == 0 &&
+			filter0->proto_port == 0)
+		return 0;
+
+	eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
+
+	if (eth_hdr->ether_type == htons(ETH_P_8021Q)) {
+		prepend += sizeof(struct vlan_eth_hdr);
+		vlan_eth_hdr = rte_pktmbuf_mtod(m, struct vlan_eth_hdr *);
+		type = vlan_eth_hdr->h_vlan_encapsulated_proto;
+	} else {
+		prepend += sizeof(struct rte_ether_hdr);
+		eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
+		type = eth_hdr->ether_type;
+	}
+
+	if (rte_pktmbuf_adj(m, prepend) == NULL)
+		goto prepend;
+
+	if (type == rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP)) {
+		struct rte_arp_hdr *arp = rte_pktmbuf_mtod(m, struct rte_arp_hdr *);
+		af = AF_INET;
+		s_addr.in.s_addr = arp->arp_data.arp_sip;
+		d_addr.in.s_addr = arp->arp_data.arp_tip;
+	} else if (type == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
+		struct rte_ipv4_hdr *ip4 = rte_pktmbuf_mtod(m, struct rte_ipv4_hdr *);
+		af = AF_INET;
+		s_addr.in.s_addr = ip4->src_addr;
+		d_addr.in.s_addr = ip4->dst_addr;
+		proto = ip4->next_proto_id;
+		iph_len = (ip4->version_ihl & 0xf) << 2;
+	} else if (type == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6)) {
+		struct rte_ipv6_hdr *ip6 = rte_pktmbuf_mtod(m, struct rte_ipv6_hdr *);
+		af = AF_INET6;
+		rte_memcpy(&s_addr.in6, &ip6->src_addr, 16);
+		rte_memcpy(&d_addr.in6, &ip6->dst_addr, 16);
+		proto = ip6->proto;
+		iph_len = sizeof(struct rte_ipv6_hdr);
+	} else {
+		goto prepend;
+	}
+
+	/* do filter */
+	if (!inet_is_addr_any(af, &filter0->s_addr) &&
+		!inet_addr_equal(af, &filter0->s_addr, &s_addr))
+		goto prepend;
+	if (!inet_is_addr_any(af, &filter0->d_addr) &&
+		!inet_addr_equal(af, &filter0->d_addr, &d_addr))
+		goto prepend;
+	if (!inet_is_addr_any(af, &filter0->host_addr) &&
+		!inet_addr_equal(af, &filter0->host_addr, &s_addr) &&
+		!inet_addr_equal(af, &filter0->host_addr, &d_addr))
+		goto prepend;
+
+	if (filter0->proto && filter0->proto != proto)
+		goto prepend;
+
+	if (filter0->s_port || filter0->d_port || filter0->proto_port) {
+		if (proto != IPPROTO_TCP && proto != IPPROTO_UDP)
+			goto prepend;
+		struct rte_udp_hdr _uh;
+		const struct rte_udp_hdr *uh;
+		uh = rte_pktmbuf_read(m, iph_len, sizeof(_uh), &_uh);
+		if (uh == NULL)
+			goto prepend;
+		if (filter0->s_port && filter0->s_port != rte_cpu_to_be_16(uh->src_port))
+			goto prepend;
+
+		if (filter0->d_port && filter0->d_port != rte_cpu_to_be_16(uh->dst_port))
+			goto prepend;
+
+		if (filter0->proto_port &&
+				filter0->proto_port != rte_cpu_to_be_16(uh->src_port) &&
+				filter0->proto_port != rte_cpu_to_be_16(uh->dst_port))
+			goto prepend;
+	}
+
+	rte_pktmbuf_prepend(m, prepend);
+	return 0;
+
+prepend:
+	rte_pktmbuf_prepend(m, prepend);
+	return -1;
+}
 
 /*
  * The packet capture statistics keep track of packets
@@ -112,6 +246,10 @@ pdump_copy(uint16_t port_id, uint16_t queue,
 			continue;
 		}
 
+        /* Apply cmdline packet filters. */
+        if (cbs->filter0 && pdump_filter(pkts[i], cbs->filter0) != 0)
+            continue;
+
 		/*
 		 * If using pcapng then want to wrap packets
 		 * otherwise a simple copy.
@@ -169,6 +307,7 @@ static int
 pdump_register_rx_callbacks(enum pdump_version ver,
 			    uint16_t end_q, uint16_t port, uint16_t queue,
 			    struct rte_ring *ring, struct rte_mempool *mp,
+			    const struct pdump_filter *filter0,
 			    struct rte_bpf *filter,
 			    uint16_t operation, uint32_t snaplen)
 {
@@ -190,6 +329,7 @@ pdump_register_rx_callbacks(enum pdump_version ver,
 			cbs->mp = mp;
 			cbs->snaplen = snaplen;
 			cbs->filter = filter;
+            cbs->filter0 = filter0;
 
 			cbs->cb = rte_eth_add_first_rx_callback(port, qid,
 								pdump_rx, cbs);
@@ -226,6 +366,7 @@ static int
 pdump_register_tx_callbacks(enum pdump_version ver,
 			    uint16_t end_q, uint16_t port, uint16_t queue,
 			    struct rte_ring *ring, struct rte_mempool *mp,
+			    const struct pdump_filter *filter0,
 			    struct rte_bpf *filter,
 			    uint16_t operation, uint32_t snaplen)
 {
@@ -248,6 +389,7 @@ pdump_register_tx_callbacks(enum pdump_version ver,
 			cbs->mp = mp;
 			cbs->snaplen = snaplen;
 			cbs->filter = filter;
+			cbs->filter0 = filter0;
 
 			cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
 								cbs);
@@ -287,6 +429,7 @@ set_pdump_rxtx_cbs(const struct pdump_request *p)
 	uint16_t port;
 	int ret = 0;
 	struct rte_bpf *filter = NULL;
+	const struct pdump_filter *filter0;
 	uint32_t flags;
 	uint16_t operation;
 	struct rte_ring *ring;
@@ -314,6 +457,7 @@ set_pdump_rxtx_cbs(const struct pdump_request *p)
 			return -rte_errno;
 		}
 	}
+	filter0 = p->filter0;
 
 	flags = p->flags;
 	operation = p->op;
@@ -365,7 +509,7 @@ set_pdump_rxtx_cbs(const struct pdump_request *p)
 	if (flags & RTE_PDUMP_FLAG_RX) {
 		end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
 		ret = pdump_register_rx_callbacks(p->ver, end_q, port, queue,
-						  ring, mp, filter,
+						  ring, mp, filter0, filter,
 						  operation, p->snaplen);
 		if (ret < 0)
 			return ret;
@@ -375,7 +519,7 @@ set_pdump_rxtx_cbs(const struct pdump_request *p)
 	if (flags & RTE_PDUMP_FLAG_TX) {
 		end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
 		ret = pdump_register_tx_callbacks(p->ver, end_q, port, queue,
-						  ring, mp, filter,
+						  ring, mp, filter0, filter,
 						  operation, p->snaplen);
 		if (ret < 0)
 			return ret;
@@ -525,6 +669,7 @@ pdump_prepare_client_request(const char *device, uint16_t queue,
 			     uint16_t operation,
 			     struct rte_ring *ring,
 			     struct rte_mempool *mp,
+                 const struct pdump_filter *filter0,
 			     const struct rte_bpf_prm *prm)
 {
 	int ret = -1;
@@ -551,6 +696,7 @@ pdump_prepare_client_request(const char *device, uint16_t queue,
 	if ((operation & ENABLE) != 0) {
 		req->ring = ring;
 		req->mp = mp;
+        req->filter0 = filter0;
 		req->prm = prm;
 		req->snaplen = snaplen;
 	}
@@ -584,6 +730,7 @@ static int
 pdump_enable(uint16_t port, uint16_t queue,
 	     uint32_t flags, uint32_t snaplen,
 	     struct rte_ring *ring, struct rte_mempool *mp,
+         const struct pdump_filter *filter0,
 	     const struct rte_bpf_prm *prm)
 {
 	int ret;
@@ -603,17 +750,17 @@ pdump_enable(uint16_t port, uint16_t queue,
 		snaplen = UINT32_MAX;
 
 	return pdump_prepare_client_request(name, queue, flags, snaplen,
-					    ENABLE, ring, mp, prm);
+					    ENABLE, ring, mp, filter0, prm);
 }
 
 int
 rte_pdump_enable(uint16_t port, uint16_t queue, uint32_t flags,
 		 struct rte_ring *ring,
 		 struct rte_mempool *mp,
-		 void *filter __rte_unused)
+		 const struct pdump_filter *filter0)
 {
 	return pdump_enable(port, queue, flags, 0,
-			    ring, mp, NULL);
+			    ring, mp, filter0, NULL);
 }
 
 int
@@ -624,7 +771,7 @@ rte_pdump_enable_bpf(uint16_t port, uint16_t queue,
 		     const struct rte_bpf_prm *prm)
 {
 	return pdump_enable(port, queue, flags, snaplen,
-			    ring, mp, prm);
+			    ring, mp, NULL, prm);
 }
 
 static int
@@ -632,6 +779,7 @@ pdump_enable_by_deviceid(const char *device_id, uint16_t queue,
 			 uint32_t flags, uint32_t snaplen,
 			 struct rte_ring *ring,
 			 struct rte_mempool *mp,
+             const struct pdump_filter *filter0,
 			 const struct rte_bpf_prm *prm)
 {
 	int ret;
@@ -647,7 +795,7 @@ pdump_enable_by_deviceid(const char *device_id, uint16_t queue,
 		snaplen = UINT32_MAX;
 
 	return pdump_prepare_client_request(device_id, queue, flags, snaplen,
-					    ENABLE, ring, mp, prm);
+					    ENABLE, ring, mp, filter0, prm);
 }
 
 int
@@ -655,10 +803,10 @@ rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
 			     uint32_t flags,
 			     struct rte_ring *ring,
 			     struct rte_mempool *mp,
-			     void *filter __rte_unused)
+			     const struct pdump_filter *filter0)
 {
 	return pdump_enable_by_deviceid(device_id, queue, flags, 0,
-					ring, mp, NULL);
+					ring, mp, filter0, NULL);
 }
 
 int
@@ -669,7 +817,7 @@ rte_pdump_enable_bpf_by_deviceid(const char *device_id, uint16_t queue,
 				 const struct rte_bpf_prm *prm)
 {
 	return pdump_enable_by_deviceid(device_id, queue, flags, snaplen,
-					ring, mp, prm);
+					ring, mp, NULL, prm);
 }
 
 int
@@ -686,7 +834,7 @@ rte_pdump_disable(uint16_t port, uint16_t queue, uint32_t flags)
 		return ret;
 
 	ret = pdump_prepare_client_request(name, queue, flags, 0,
-					   DISABLE, NULL, NULL, NULL);
+					   DISABLE, NULL, NULL, NULL, NULL);
 
 	return ret;
 }
@@ -702,7 +850,7 @@ rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
 		return ret;
 
 	ret = pdump_prepare_client_request(device_id, queue, flags, 0,
-					   DISABLE, NULL, NULL, NULL);
+					   DISABLE, NULL, NULL, NULL, NULL);
 
 	return ret;
 }
diff --git a/lib/pdump/rte_pdump.h b/lib/pdump/rte_pdump.h
index 1e32d46..b44b222 100644
--- a/lib/pdump/rte_pdump.h
+++ b/lib/pdump/rte_pdump.h
@@ -15,6 +15,8 @@
 #include <stdint.h>
 
 #include <rte_bpf.h>
+#include <arpa/inet.h>
+#include <linux/if_ether.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -31,6 +33,31 @@ enum {
 	RTE_PDUMP_FLAG_PCAPNG = 4, /* format for pcapng */
 };
 
+union addr {
+	struct in_addr      in;
+	struct in6_addr     in6;
+};
+
+struct pdump_filter {
+	int         af;
+	union addr  s_addr;
+	union addr  d_addr;
+	union addr  host_addr; //s_addr or d_addr
+
+	uint8_t     proto;
+	uint16_t    proto_port; //s_port or d_port
+	uint16_t    s_port;
+	uint16_t    d_port;
+};
+
+struct vlan_eth_hdr {
+	unsigned char   h_dest[ETH_ALEN];
+	unsigned char   h_source[ETH_ALEN];
+	unsigned short  h_vlan_proto;
+	unsigned short  h_vlan_TCI;
+	unsigned short  h_vlan_encapsulated_proto;
+};
+
 /**
  * Initialize packet capturing handling
  *
@@ -69,8 +96,8 @@ rte_pdump_uninit(void);
  *  ring on which captured packets will be enqueued for user.
  * @param mp
  *  mempool on to which original packets will be mirrored or duplicated.
- * @param filter
- *  Unused should be NULL.
+ * @param filter0
+ *  cmdline packet filter
  *
  * @return
  *    0 on success, -1 on error, rte_errno is set accordingly.
@@ -80,7 +107,7 @@ int
 rte_pdump_enable(uint16_t port, uint16_t queue, uint32_t flags,
 		struct rte_ring *ring,
 		struct rte_mempool *mp,
-		void *filter);
+		const struct pdump_filter *filter0);
 
 /**
  * Enables packet capturing on given port and queue with filtering.
@@ -150,8 +177,8 @@ rte_pdump_disable(uint16_t port, uint16_t queue, uint32_t flags);
  *  ring on which captured packets will be enqueued for user.
  * @param mp
  *  mempool on to which original packets will be mirrored or duplicated.
- * @param filter
- *  unused should be NULL
+ * @param filter0
+ *  cmdline packet filter
  *
  * @return
  *    0 on success, -1 on error, rte_errno is set accordingly.
@@ -162,7 +189,7 @@ rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
 				uint32_t flags,
 				struct rte_ring *ring,
 				struct rte_mempool *mp,
-				void *filter);
+				const struct pdump_filter *filter0);
 
 /**
  * Enables packet capturing on given device id and queue with filtering.
-- 
2.31.1