Squashed 'external/toxcore/c-toxcore/' changes from 8f0d505f9a..6d634674a9

6d634674a9 cleanup: Remove old type-ordered event getters.
d1d48d1dfc feat: add ngc events
994ffecc6b refactor: Make event dispatch ordered by receive time.
812f931d5f fix: Make sure there's enough space for CONSUME1 in fuzzers.
50f1b30fa9 test: Add fuzz tests to the coverage run.
df76f5cf47 chore: Move from gcov to llvm source-based coverage.
072e3beb3f fix: issues with packet broadcast error reporting
6b6718e4d2 cleanup: Make group packet entry creation less error-prone
5b9c420ce1 refactor: packet broadcast functions now return errors
af4cb31028 refactor: Use `operator==` for equality tests of `Node_format`.
9592d590cf refactor(test): Slightly nicer C++ interface to tox Random.
c66e10fb7a refactor: Minor refactoring of get_close_nodes functions.
ebc9643862 fix: don't pass garbage data buffer to packet send functions
32b68cffca cleanup: Some more test cleanups, removing overly smart code.
0426624dcb refactor: Assign malloc return to a local variable first.
afc38f2458 test: Add more unit tests for `add_to_list`.
05ce5c1ab9 test: Add "infer" CI check to github, remove from circle.
REVERT: 8f0d505f9a feat: add ngc events
REVERT: 9b8216e70c refactor: Make event dispatch ordered by receive time.

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: 6d634674a929edb0ab70689dcbcb195b3547be13

testing/fuzzing/fuzz_support.h

@@ -7,11 +7,12 @@
 
 #include <cstdint>
 #include <cstdlib>
+#include <cstring>
 #include <deque>
 #include <memory>
-#include <vector>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include "../../toxcore/tox.h"
 
@@ -20,19 +21,28 @@ struct Fuzz_Data {
     std::size_t size;
 
     Fuzz_Data(const uint8_t *input_data, std::size_t input_size)
-        : data(input_data), size(input_size)
-    {}
+        : data(input_data)
+        , size(input_size)
+    {
+    }
 
     Fuzz_Data &operator=(const Fuzz_Data &rhs) = delete;
     Fuzz_Data(const Fuzz_Data &rhs) = delete;
 
-    uint8_t consume1()
-    {
-        const uint8_t val = data[0];
-        ++data;
-        --size;
-        return val;
-    }
+    struct Consumer {
+        Fuzz_Data &fd;
+
+        template <typename T>
+        operator T()
+        {
+            const uint8_t *bytes = fd.consume(sizeof(T));
+            T val;
+            std::memcpy(&val, bytes, sizeof(T));
+            return val;
+        }
+    };
+
+    Consumer consume1() { return Consumer{*this}; }
 
     const uint8_t *consume(std::size_t count)
     {
@@ -50,14 +60,14 @@ struct Fuzz_Data {
  *
  * @example
  * @code
- * CONSUME1_OR_RETURN(const uint8_t one_byte, input);
+ * CONSUME1_OR_RETURN(const uint8_t, one_byte, input);
  * @endcode
  */
-#define CONSUME1_OR_RETURN(DECL, INPUT) \
-    if (INPUT.size < 1) {               \
-        return;                         \
-    }                                   \
-    DECL = INPUT.consume1()
+#define CONSUME1_OR_RETURN(TYPE, NAME, INPUT) \
+    if (INPUT.size < sizeof(TYPE)) {          \
+        return;                               \
+    }                                         \
+    TYPE NAME = INPUT.consume1()
 
 /** @brief Consumes 1 byte of the fuzzer input or returns a value if no data
  * available.
@@ -70,11 +80,11 @@ struct Fuzz_Data {
  * CONSUME1_OR_RETURN_VAL(const uint8_t one_byte, input, nullptr);
  * @endcode
  */
-#define CONSUME1_OR_RETURN_VAL(DECL, INPUT, VAL) \
-    if (INPUT.size < 1) {                        \
-        return VAL;                              \
-    }                                            \
-    DECL = INPUT.consume1()
+#define CONSUME1_OR_RETURN_VAL(TYPE, NAME, INPUT, VAL) \
+    if (INPUT.size < sizeof(TYPE)) {                   \
+        return VAL;                                    \
+    }                                                  \
+    TYPE NAME = INPUT.consume1()
 
 /** @brief Consumes SIZE bytes of the fuzzer input or returns if not enough data available.
  *
@@ -93,6 +103,12 @@ struct Fuzz_Data {
     }                                        \
     DECL = INPUT.consume(SIZE)
 
+#define CONSUME_OR_RETURN_VAL(DECL, INPUT, SIZE, VAL) \
+    if (INPUT.size < SIZE) {                          \
+        return VAL;                                   \
+    }                                                 \
+    DECL = INPUT.consume(SIZE)
+
 inline void fuzz_select_target(uint8_t selector, Fuzz_Data &input)
 {
     // The selector selected no function, so we do nothing and rely on the
@@ -100,7 +116,7 @@ inline void fuzz_select_target(uint8_t selector, Fuzz_Data &input)
 }
 
 template <typename Arg, typename... Args>
-void fuzz_select_target(uint8_t selector, Fuzz_Data &input, Arg &&fn, Args &&... args)
+void fuzz_select_target(uint8_t selector, Fuzz_Data &input, Arg &&fn, Args &&...args)
 {
     if (selector == sizeof...(Args)) {
         return fn(input);
@@ -109,11 +125,11 @@ void fuzz_select_target(uint8_t selector, Fuzz_Data &input, Arg &&fn, Args &&...
 }
 
 template <typename... Args>
-void fuzz_select_target(const uint8_t *data, std::size_t size, Args &&... args)
+void fuzz_select_target(const uint8_t *data, std::size_t size, Args &&...args)
 {
     Fuzz_Data input{data, size};
 
-    CONSUME1_OR_RETURN(uint8_t selector, input);
+    CONSUME1_OR_RETURN(const uint8_t, selector, input);
     return fuzz_select_target(selector, input, std::forward<Args>(args)...);
 }
 
@@ -127,6 +143,10 @@ struct System {
     std::unique_ptr<Network> ns;
     std::unique_ptr<Random> rng;
 
+    System(std::unique_ptr<Tox_System> sys, std::unique_ptr<Memory> mem,
+        std::unique_ptr<Network> ns, std::unique_ptr<Random> rng);
+    System(System &&);
+
     // Not inline because sizeof of the above 2 structs is not known everywhere.
     ~System();