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

[libpcap] / pcap-dag.c

diff --git a/pcap-dag.c b/pcap-dag.c
index d4b0f02953349c263e91885a136453effaf413a4..f261ead00df8a0c3bdcbe47206d03b180b883f94 100644 (file)
--- a/pcap-dag.c
+++ b/pcap-dag.c
@@ -19,7 +19,6 @@
 
 #include "pcap-int.h"
 
-#include <ctype.h>
 #include <netinet/in.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
@@ -214,7 +213,7 @@ static int dag_get_datalink(pcap_t *p);
 static int dag_setnonblock(pcap_t *p, int nonblock);
 
 static void
-delete_pcap_dag(pcap_t *p)
+delete_pcap_dag(const pcap_t *p)
 {
        pcap_dag_node_t *curr = NULL, *prev = NULL;
 
@@ -300,7 +299,7 @@ new_pcap_dag(pcap_t *p)
 }
 
 static unsigned int
-dag_erf_ext_header_count(uint8_t * erf, size_t len)
+dag_erf_ext_header_count(const uint8_t *erf, size_t len)
 {
        uint32_t hdr_num = 0;
        uint8_t  hdr_type;
@@ -334,7 +333,7 @@ dag_erf_ext_header_count(uint8_t * erf, size_t len)
 /*
  *  Read at most max_packets from the capture stream and call the callback
  *  for each of them. Returns the number of packets handled, -1 if an
- *  error occured, or -2 if we were told to break out of the loop.
+ *  error occurred, or -2 if we were told to break out of the loop.
  */
 static int
 dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
@@ -392,7 +391,12 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 
        }
 
-       /* Process the packets. */
+       /*
+        * Process the packets.
+        *
+        * This assumes that a single buffer of packets will have
+        * <= INT_MAX packets, so the packet count doesn't overflow.
+        */
        while (pd->dag_mem_top - pd->dag_mem_bottom >= dag_record_size) {
 
                unsigned short packet_len = 0;
@@ -420,7 +424,8 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                rlen = ntohs(header->rlen);
                if (rlen < dag_record_size)
                {
-                       strncpy(p->errbuf, "dag_read: record too small", PCAP_ERRBUF_SIZE);
+                       pcap_strlcpy(p->errbuf, "dag_read: record too small",
+                           PCAP_ERRBUF_SIZE);
                        return -1;
                }
                pd->dag_mem_bottom += rlen;
@@ -731,7 +736,7 @@ dag_inject(pcap_t *p, const void *buf _U_, int size _U_)
  *  API polling parameters.
  *
  *  snaplen is now also ignored, until we get per-stream slen support. Set
- *  slen with approprite DAG tool BEFORE pcap_activate().
+ *  slen with appropriate DAG tool BEFORE pcap_activate().
  *
  *  See also pcap(3).
  */
@@ -788,14 +793,23 @@ static int dag_activate(pcap_t* p)
                /*
                 * XXX - does this reliably set errno?
                 */
-               if (errno == ENOENT)
+               if (errno == ENOENT) {
+                       /*
+                        * There's nothing more to say, so clear
+                        * the error message.
+                        */
                        ret = PCAP_ERROR_NO_SUCH_DEVICE;
-               else if (errno == EPERM || errno == EACCES)
+                       p->errbuf[0] = '\0';
+               } else if (errno == EPERM || errno == EACCES) {
                        ret = PCAP_ERROR_PERM_DENIED;
-               else
+                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                           "Attempt to open %s failed with %s - additional privileges may be required",
+                           device, (errno == EPERM) ? "EPERM" : "EACCES");
+               } else {
                        ret = PCAP_ERROR;
-               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
-                   errno, "dag_config_init %s", device);
+                       pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                           errno, "dag_config_init %s", device);
+               }
                goto fail;
        }
 
@@ -945,7 +959,7 @@ static int dag_activate(pcap_t* p)
                 * Did the user request that they not be stripped?
                 */
                if ((s = getenv("ERF_DONT_STRIP_FCS")) != NULL) {
-                       /* Yes.  Note the number of bytes that will be
+                       /* Yes.  Note the number of 16-bit words that will be
                           supplied. */
                        p->linktype_ext = LT_FCS_DATALINK_EXT(pd->dag_fcs_bits/16);
 
@@ -1071,7 +1085,7 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
        /* OK, it's probably ours. */
        *is_ours = 1;
 
-       p = pcap_create_common(ebuf, sizeof (struct pcap_dag));
+       p = PCAP_CREATE_COMMON(ebuf, struct pcap_dag);
        if (p == NULL)
                return NULL;
 
@@ -1084,7 +1098,6 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
         * XXX Our native precision is 2^-32s, but libpcap doesn't support
         * power of two precisions yet. We can convert to either MICRO or NANO.
         */
-       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,
@@ -1094,6 +1107,7 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
        }
        p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
        p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
+       p->tstamp_precision_count = 2;
        return p;
 }
 
@@ -1114,7 +1128,7 @@ dag_stats(pcap_t *p, struct pcap_stat *ps) {
                /* Note this counter is cleared at start of capture and will wrap at UINT_MAX.
                 * The application is responsible for polling ps_drop frequently enough
                 * to detect each wrap and integrate total drop with a wider counter */
-               if ((dag_error = dag_config_get_uint32_attribute_ex(pd->dag_ref, pd->drop_attr, &stream_drop) == kDagErrNone)) {
+               if ((dag_error = dag_config_get_uint32_attribute_ex(pd->dag_ref, pd->drop_attr, &stream_drop)) == kDagErrNone) {
                        pd->stat.ps_drop = stream_drop;
                } else {
                        snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "reading stream drop attribute: %s",