Src div0 5920 v2

src/flow.c

@@ -606,9 +606,10 @@ void FlowInitConfig(bool quiet)
             FatalError("Invalid value for flow.hash-size: NULL");
         }
 
-        if (StringParseUint32(&configval, 10, strlen(conf_val),
-                                    conf_val) > 0) {
+        if (StringParseUint32(&configval, 10, strlen(conf_val), conf_val) > 0 || configval == 0) {
             flow_config.hash_size = configval;
+        } else {
+            FatalError("Invalid value for flow.hash-size");
         }
     }
     if ((ConfGet("flow.prealloc", &conf_val)) == 1)

src/source-dpdk.c

@@ -151,12 +151,18 @@ static void DPDKFreeMbufArray(struct rte_mbuf **mbuf_array, uint16_t mbuf_cnt, u
 static uint64_t CyclesToMicroseconds(const uint64_t cycles)
 {
     const uint64_t ticks_per_us = rte_get_tsc_hz() / 1000000;
+    if (ticks_per_us == 0) {
+        return 0;
+    }
     return cycles / ticks_per_us;
 }
 
 static uint64_t CyclesToSeconds(const uint64_t cycles)
 {
     const uint64_t ticks_per_s = rte_get_tsc_hz();
+    if (ticks_per_s == 0) {
+        return 0;
+    }
     return cycles / ticks_per_s;
 }
 

src/source-windivert.c

@@ -233,8 +233,10 @@ static SCTime_t WinDivertTimestampToTimeStamp(WinDivertThreadVars *wd_tv, INT64
     struct timeval tv;
 
     int64_t qpc_delta = (int64_t)timestamp_count - wd_tv->qpc_start_count;
-    int64_t unix_usec =
-            wd_tv->qpc_start_time + (qpc_delta / wd_tv->qpc_freq_usec);
+    int64_t unix_usec = wd_tv->qpc_start_time;
+    if (wd_tv->qpc_freq_usec) {
+        unix_usec += qpc_delta / wd_tv->qpc_freq_usec;
+    }
 
     tv.tv_sec = (long)(unix_usec / (1000 * 1000));
     tv.tv_usec = (long)(unix_usec - (int64_t)tv.tv_sec * (1000 * 1000));

src/util-device.c

@@ -318,10 +318,11 @@ int LiveDeviceListClean(void)
 
     TAILQ_FOREACH_SAFE(pd, &live_devices, next, tpd) {
         if (live_devices_stats) {
+            uint64_t pkts = SC_ATOMIC_GET(pd->pkts);
             SCLogNotice("%s: packets: %" PRIu64 ", drops: %" PRIu64
                         " (%.2f%%), invalid chksum: %" PRIu64,
-                    pd->dev, SC_ATOMIC_GET(pd->pkts), SC_ATOMIC_GET(pd->drop),
-                    100 * ((double)SC_ATOMIC_GET(pd->drop)) / (double)SC_ATOMIC_GET(pd->pkts),
+                    pd->dev, pkts, SC_ATOMIC_GET(pd->drop),
+                    pkts ? 100 * ((double)SC_ATOMIC_GET(pd->drop)) / (double)pkts : 0,
                     SC_ATOMIC_GET(pd->invalid_checksums));
         }
 

src/util-pool.c

@@ -378,12 +378,14 @@ void PoolReturn(Pool *p, void *data)
 
 void PoolPrintSaturation(Pool *p)
 {
-    SCLogDebug("pool %p is using %" PRIu32 " out of %" PRIu32 " items (%02.1f%%), max %" PRIu32
-               " (%02.1f%%): pool struct memory %" PRIu64 ".",
-            p, p->outstanding, p->max_buckets,
-            (float)(p->outstanding) / (float)(p->max_buckets) * 100, p->max_outstanding,
-            (float)(p->max_outstanding) / (float)(p->max_buckets) * 100,
-            (uint64_t)(p->max_buckets * sizeof(PoolBucket)));
+    if (p->max_buckets > 0) {
+        SCLogDebug("pool %p is using %" PRIu32 " out of %" PRIu32 " items (%02.1f%%), max %" PRIu32
+                   " (%02.1f%%): pool struct memory %" PRIu64 ".",
+                p, p->outstanding, p->max_buckets,
+                (float)(p->outstanding) / (float)(p->max_buckets) * 100, p->max_outstanding,
+                (float)(p->max_outstanding) / (float)(p->max_buckets) * 100,
+                (uint64_t)(p->max_buckets * sizeof(PoolBucket)));
+    }
 }
 
 /*

src/util-profiling-prefilter.c

@@ -121,7 +121,7 @@ static void DoDump(SCProfilePrefilterDetectCtx *rules_ctx, FILE *fp, const char
             avgticks = (double)(ticks / d->called);
         }
         double avgbytes = 0;
-        if (d->total_bytes && d->called) {
+        if (d->total_bytes && d->bytes_called) {
             avgbytes = (double)(d->total_bytes / d->bytes_called);
         }
         double ticks_per_byte = 0;

src/util-profiling-rules.c

@@ -441,7 +441,7 @@ static void *SCProfilingRuleDump(SCProfileDetectCtx *rules_ctx, int file_output)
         summary[i].ticks = rules_ctx->data[i].ticks_match + rules_ctx->data[i].ticks_no_match;
         summary[i].checks = rules_ctx->data[i].checks;
 
-        if (summary[i].ticks > 0) {
+        if (summary[i].checks > 0) {
             summary[i].avgticks = (long double)summary[i].ticks / (long double)summary[i].checks;
         }