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 4df1527434ea6d5a101e547c7ad993951468dd55..f261ead00df8a0c3bdcbe47206d03b180b883f94 100644 (file)
--- a/pcap-dag.c
+++ b/pcap-dag.c
@@ -213,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;
 
@@ -299,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;
@@ -333,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)
@@ -391,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;
@@ -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);
 
@@ -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;
 }