X-Git-Url: https://git.tcpdump.org/libpcap/blobdiff_plain/16782c7e7811c2bc821c1f58ae948af7bccf81fe..HEAD:/pcap-netfilter-linux.c

diff --git a/pcap-netfilter-linux.c b/pcap-netfilter-linux.c
index d9550b02..90296be7 100644
--- a/pcap-netfilter-linux.c
+++ b/pcap-netfilter-linux.c
@@ -28,17 +28,11 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifdef HAVE_CONFIG_H
 #include <config.h>
-#endif
 
 #include "pcap-int.h"
 #include "diag-control.h"
 
-#ifdef NEED_STRERROR_H
-#include "strerror.h"
-#endif
-
 #include <errno.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -61,7 +55,7 @@
  *       It took me quite some time to debug ;/
  *
  *       Sending any data to nfnetlink socket requires CAP_NET_ADMIN privileges,
- *       and in nfqueue we need to send verdict reply after recving packet.
+ *       and in nfqueue we need to send verdict reply after receiving packet.
  *
  *       In tcpdump you can disable dropping privileges with -Z root
  */
@@ -92,7 +86,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 	struct pcap_netfilter *handlep = handle->priv;
 	register u_char *bp, *ep;
 	int count = 0;
-	ssize_t len;
+	u_int cc;
 
 	/*
 	 * Has "pcap_breakloop()" been called?
@@ -106,8 +100,8 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 		handle->break_loop = 0;
 		return PCAP_ERROR_BREAK;
 	}
-	len = handle->cc;
-	if (len == 0) {
+	cc = handle->cc;
+	if (cc == 0) {
 		/*
 		 * The buffer is empty; refill it.
 		 *
@@ -117,26 +111,42 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 		 * to set handle->break_loop (we ignore it on other
 		 * platforms as well).
 		 */
+		ssize_t read_ret;
+
 		do {
-			len = recv(handle->fd, handle->buffer, handle->bufsize, 0);
+			read_ret = recv(handle->fd, handle->buffer, handle->bufsize, 0);
 			if (handle->break_loop) {
 				handle->break_loop = 0;
 				return PCAP_ERROR_BREAK;
 			}
-			if (errno == ENOBUFS)
+			if (read_ret == -1 && errno == ENOBUFS)
 				handlep->packets_nobufs++;
-		} while ((len == -1) && (errno == EINTR || errno == ENOBUFS));
+		} while ((read_ret == -1) && (errno == EINTR || errno == ENOBUFS));
 
-		if (len < 0) {
-			pcap_fmt_errmsg_for_errno(handle->errbuf,
+		if (read_ret < 0) {
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
 			    PCAP_ERRBUF_SIZE, errno, "Can't receive packet");
 			return PCAP_ERROR;
 		}
 
+		/*
+		 * At this point, read_ret is guaranteed to be
+		 * >= 0 and < p->bufsize; p->bufsize is a u_int,
+		 * so its value is guaranteed to fit in cc, which
+		 * is also a u_int.
+		 */
+		cc = (u_int)read_ret;
 		bp = (unsigned char *)handle->buffer;
 	} else
 		bp = handle->bp;
-	ep = bp + len;
+
+	/*
+	 * Loop through each message.
+	 *
+	 * This assumes that a single buffer of message will have
+	 * <= INT_MAX packets, so the message count doesn't overflow.
+	 */
+	ep = bp + cc;
 	while (bp < ep) {
 		const struct nlmsghdr *nlh = (const struct nlmsghdr *) bp;
 		uint32_t msg_len;
@@ -153,7 +163,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 		 */
 		if (handle->break_loop) {
 			handle->bp = bp;
-			handle->cc = (int)(ep - bp);
+			handle->cc = (u_int)(ep - bp);
 			if (count == 0) {
 				handle->break_loop = 0;
 				return PCAP_ERROR_BREAK;
@@ -179,8 +189,8 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 			break;
 		}
 
-		if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || (u_int)len < nlh->nlmsg_len) {
-			snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %zd) (nlmsg_len: %u)", len, nlh->nlmsg_len);
+		if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || cc < nlh->nlmsg_len) {
+			snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %u) (nlmsg_len: %u)", cc, nlh->nlmsg_len);
 			return -1;
 		}
 
@@ -252,7 +262,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 
 				gettimeofday(&pkth.ts, NULL);
 				if (handle->fcode.bf_insns == NULL ||
-						pcap_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen))
+						pcapint_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen))
 				{
 					handlep->packets_read++;
 					callback(user, &pkth, payload);
@@ -288,9 +298,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 		bp += msg_len;
 		if (count >= max_packets && !PACKET_COUNT_IS_UNLIMITED(max_packets)) {
 			handle->bp = bp;
-			handle->cc = (int)(ep - bp);
-			if (handle->cc < 0)
-				handle->cc = 0;
+			handle->cc = (u_int)(ep - bp);
 			return count;
 		}
 	}
@@ -519,8 +527,8 @@ netfilter_activate(pcap_t* handle)
 	nftype_t type = OTHER;
 	int i;
 
- 	if (strncmp(dev, NFLOG_IFACE, strlen(NFLOG_IFACE)) == 0) {
- 		dev += strlen(NFLOG_IFACE);
+	if (strncmp(dev, NFLOG_IFACE, strlen(NFLOG_IFACE)) == 0) {
+		dev += strlen(NFLOG_IFACE);
 		type = NFLOG;
 
 	} else if (strncmp(dev, NFQUEUE_IFACE, strlen(NFQUEUE_IFACE)) == 0) {
@@ -588,17 +596,17 @@ netfilter_activate(pcap_t* handle)
 	handle->offset = 0;
 	handle->read_op = netfilter_read_linux;
 	handle->inject_op = netfilter_inject_linux;
-	handle->setfilter_op = install_bpf_program; /* no kernel filtering */
+	handle->setfilter_op = pcapint_install_bpf_program; /* no kernel filtering */
 	handle->setdirection_op = NULL;
 	handle->set_datalink_op = netfilter_set_datalink;
-	handle->getnonblock_op = pcap_getnonblock_fd;
-	handle->setnonblock_op = pcap_setnonblock_fd;
+	handle->getnonblock_op = pcapint_getnonblock_fd;
+	handle->setnonblock_op = pcapint_setnonblock_fd;
 	handle->stats_op = netfilter_stats_linux;
 
 	/* Create netlink socket */
 	handle->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER);
 	if (handle->fd < 0) {
-		pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
+		pcapint_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
 		    errno, "Can't create raw socket");
 		return PCAP_ERROR;
 	}
@@ -606,32 +614,35 @@ netfilter_activate(pcap_t* handle)
 	if (type == NFLOG) {
 		handle->linktype = DLT_NFLOG;
 		handle->dlt_list = (u_int *) malloc(sizeof(u_int) * 2);
-		if (handle->dlt_list != NULL) {
-			handle->dlt_list[0] = DLT_NFLOG;
-			handle->dlt_list[1] = DLT_IPV4;
-			handle->dlt_count = 2;
+		if (handle->dlt_list == NULL) {
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
+			    PCAP_ERRBUF_SIZE, errno,
+			    "Can't allocate DLT list");
+			goto close_fail;
 		}
-
+		handle->dlt_list[0] = DLT_NFLOG;
+		handle->dlt_list[1] = DLT_IPV4;
+		handle->dlt_count = 2;
 	} else
 		handle->linktype = DLT_IPV4;
 
 	handle->buffer = malloc(handle->bufsize);
 	if (!handle->buffer) {
-		pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
+		pcapint_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
 		    errno, "Can't allocate dump buffer");
 		goto close_fail;
 	}
 
 	if (type == NFLOG) {
 		if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
-			pcap_fmt_errmsg_for_errno(handle->errbuf,
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
 			    PCAP_ERRBUF_SIZE, errno,
 			    "NFULNL_CFG_CMD_PF_UNBIND");
 			goto close_fail;
 		}
 
 		if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
-			pcap_fmt_errmsg_for_errno(handle->errbuf,
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
 			    PCAP_ERRBUF_SIZE, errno, "NFULNL_CFG_CMD_PF_BIND");
 			goto close_fail;
 		}
@@ -639,14 +650,14 @@ netfilter_activate(pcap_t* handle)
 		/* Bind socket to the nflog groups */
 		for (i = 0; i < group_count; i++) {
 			if (nflog_send_config_cmd(handle, groups[i], NFULNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
-				pcap_fmt_errmsg_for_errno(handle->errbuf,
+				pcapint_fmt_errmsg_for_errno(handle->errbuf,
 				    PCAP_ERRBUF_SIZE, errno,
 				    "Can't listen on group index");
 				goto close_fail;
 			}
 
 			if (nflog_send_config_mode(handle, groups[i], NFULNL_COPY_PACKET, handle->snapshot) < 0) {
-				pcap_fmt_errmsg_for_errno(handle->errbuf,
+				pcapint_fmt_errmsg_for_errno(handle->errbuf,
 				    PCAP_ERRBUF_SIZE, errno,
 				    "NFULNL_COPY_PACKET");
 				goto close_fail;
@@ -655,13 +666,13 @@ netfilter_activate(pcap_t* handle)
 
 	} else {
 		if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
-			pcap_fmt_errmsg_for_errno(handle->errbuf,
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
 			    PCAP_ERRBUF_SIZE, errno, "NFQNL_CFG_CMD_PF_UNBIND");
 			goto close_fail;
 		}
 
 		if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
-			pcap_fmt_errmsg_for_errno(handle->errbuf,
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
 			    PCAP_ERRBUF_SIZE, errno, "NFQNL_CFG_CMD_PF_BIND");
 			goto close_fail;
 		}
@@ -669,14 +680,14 @@ netfilter_activate(pcap_t* handle)
 		/* Bind socket to the nfqueue groups */
 		for (i = 0; i < group_count; i++) {
 			if (nfqueue_send_config_cmd(handle, groups[i], NFQNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
-				pcap_fmt_errmsg_for_errno(handle->errbuf,
+				pcapint_fmt_errmsg_for_errno(handle->errbuf,
 				    PCAP_ERRBUF_SIZE, errno,
 				    "Can't listen on group index");
 				goto close_fail;
 			}
 
 			if (nfqueue_send_config_mode(handle, groups[i], NFQNL_COPY_PACKET, handle->snapshot) < 0) {
-				pcap_fmt_errmsg_for_errno(handle->errbuf,
+				pcapint_fmt_errmsg_for_errno(handle->errbuf,
 				    PCAP_ERRBUF_SIZE, errno,
 				    "NFQNL_COPY_PACKET");
 				goto close_fail;
@@ -688,7 +699,7 @@ netfilter_activate(pcap_t* handle)
 		/*
 		 * Monitor mode doesn't apply to netfilter devices.
 		 */
-		pcap_cleanup_live_common(handle);
+		pcapint_cleanup_live_common(handle);
 		return PCAP_ERROR_RFMON_NOTSUP;
 	}
 
@@ -697,7 +708,7 @@ netfilter_activate(pcap_t* handle)
 		 * Set the socket buffer size to the specified value.
 		 */
 		if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF, &handle->opt.buffer_size, sizeof(handle->opt.buffer_size)) == -1) {
-			pcap_fmt_errmsg_for_errno(handle->errbuf,
+			pcapint_fmt_errmsg_for_errno(handle->errbuf,
 			    PCAP_ERRBUF_SIZE, errno, "SO_RCVBUF");
 			goto close_fail;
 		}
@@ -707,7 +718,7 @@ netfilter_activate(pcap_t* handle)
 	return 0;
 
 close_fail:
-	pcap_cleanup_live_common(handle);
+	pcapint_cleanup_live_common(handle);
 	return PCAP_ERROR;
 }
 
@@ -718,9 +729,7 @@ netfilter_create(const char *device, char *ebuf, int *is_ours)
 	pcap_t *p;
 
 	/* Does this look like an netfilter device? */
-	cp = strrchr(device, '/');
-	if (cp == NULL)
-		cp = device;
+	cp = device;
 
 	/* Does it begin with NFLOG_IFACE or NFQUEUE_IFACE? */
 	if (strncmp(cp, NFLOG_IFACE, sizeof NFLOG_IFACE - 1) == 0)
@@ -764,7 +773,7 @@ netfilter_findalldevs(pcap_if_list_t *devlistp, char *err_str)
 		/* if netlink is not supported this is not fatal */
 		if (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT)
 			return 0;
-		pcap_fmt_errmsg_for_errno(err_str, PCAP_ERRBUF_SIZE,
+		pcapint_fmt_errmsg_for_errno(err_str, PCAP_ERRBUF_SIZE,
 		    errno, "Can't open netlink socket");
 		return -1;
 	}
@@ -774,11 +783,11 @@ netfilter_findalldevs(pcap_if_list_t *devlistp, char *err_str)
 	 * The notion of "connected" vs. "disconnected" doesn't apply.
 	 * XXX - what about "up" and "running"?
 	 */
-	if (add_dev(devlistp, NFLOG_IFACE,
+	if (pcapint_add_dev(devlistp, NFLOG_IFACE,
 	    PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE,
 	    "Linux netfilter log (NFLOG) interface", err_str) == NULL)
 		return -1;
-	if (add_dev(devlistp, NFQUEUE_IFACE,
+	if (pcapint_add_dev(devlistp, NFQUEUE_IFACE,
 	    PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE,
 	    "Linux netfilter queue (NFQUEUE) interface", err_str) == NULL)
 		return -1;