Update config.{guess,sub}, timestamps 2023-01-01,2023-01-21

[libpcap] / pcap-snit.c

diff --git a/pcap-snit.c b/pcap-snit.c
index 9da8573d96fd55cd0c3af33c07a7ae8d58f8faeb..3f4e69d7186329c8018d504652e667b1ee5c27e6 100644 (file)
--- a/pcap-snit.c
+++ b/pcap-snit.c
@@ -53,7 +53,6 @@
 #include <netinet/tcp.h>
 #include <netinet/tcpip.h>
 
-#include <ctype.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
@@ -140,6 +139,9 @@ pcap_read_snit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 
        /*
         * loop through each snapshot in the chunk
+        *
+        * This assumes that a single buffer of packets will have
+        * <= INT_MAX packets, so the packet count doesn't overflow.
         */
        n = 0;
        ep = bp + cc;
@@ -190,7 +192,7 @@ pcap_read_snit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                if (caplen > p->snapshot)
                        caplen = p->snapshot;
 
-               if (bpf_filter(p->fcode.bf_insns, cp, nlp->nh_pktlen, caplen)) {
+               if (pcap_filter(p->fcode.bf_insns, cp, nlp->nh_pktlen, caplen)) {
                        struct pcap_pkthdr h;
                        h.ts = ntp->nh_timestamp;
                        h.len = nlp->nh_pktlen;
@@ -208,7 +210,7 @@ pcap_read_snit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 }
 
 static int
-pcap_inject_snit(pcap_t *p, const void *buf, size_t size)
+pcap_inject_snit(pcap_t *p, const void *buf, int size)
 {
        struct strbuf ctl, data;
 
@@ -332,12 +334,16 @@ pcap_activate_snit(pcap_t *p)
        if (fd < 0 && errno == EACCES)
                p->fd = fd = open(dev, O_RDONLY);
        if (fd < 0) {
-               if (errno == EACCES)
+               if (errno == EACCES) {
                        err = PCAP_ERROR_PERM_DENIED;
-               else
+                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                           "Attempt to open %s failed with EACCES - root privileges may be required",
+                           dev);
+               } else {
                        err = PCAP_ERROR;
-               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
-                   errno, "%s", dev);
+                       pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                           errno, "%s", dev);
+               }
                goto bad;
        }
 
@@ -460,7 +466,7 @@ pcap_create_interface(const char *device _U_, char *ebuf)
 {
        pcap_t *p;
 
-       p = pcap_create_common(ebuf, sizeof (struct pcap_snit));
+       p = PCAP_CREATE_COMMON(ebuf, struct pcap_snit);
        if (p == NULL)
                return (NULL);
 
@@ -478,10 +484,22 @@ can_be_bound(const char *name _U_)
        return (1);
 }
 
+static int
+get_if_flags(const char *name _U_, bpf_u_int32 *flags _U_, char *errbuf _U_)
+{
+       /*
+        * Nothing we can do.
+        * XXX - is there a way to find out whether an adapter has
+        * something plugged into it?
+        */
+       return (0);
+}
+
 int
 pcap_platform_finddevs(pcap_if_list_t *devlistp, char *errbuf)
 {
-       return (pcap_findalldevs_interfaces(devlistp, errbuf, can_be_bound));
+       return (pcap_findalldevs_interfaces(devlistp, errbuf, can_be_bound,
+           get_if_flags));
 }
 
 /*