Merge commit '9ddeea3d06045c8ae38cd2d6eed0fc2891c6e146'

adbd5b32d8 feat: add ngc events
15ee46d431 add simple test for max sized lossy custom group packet
01e7950c67 increase lossy custom packet size in ngc to the toxcore common max of 1373
9b3c1089f1 Make group saving/loading more forgiving with data errors
55a76003b0 Replace memset(int32_t*, -1, _) with a for-loop
66453439ac fix: also Install header for private/experimental API functions with autotools
3983369103 fix: Enable debug flag for ubsan.
4d1db21102 Update tox-boostrapd hash
e700c31b70 Fix memory leak in group connection
2994441d9c Fix memory leak in save-generator
d0400df13d Fix memory leak in tox-bootstrapd
7a6d50ebe3 Install header for private/experimental API functions
d89677fb5f Remove defunct IRC channel from README.md
26d41fc604 Replace DEFAULT_TCP_RELAY_PORTS_COUNT with a compile-time calculation
63fb2941ca Clarify disabling of static assert checks
65b3375b98 refactor: Use Bin_Pack for packing Node_format.
84ba154f6a group connection queries now return our own connection type
a4df2862ed Replace tabs with spaces
1b6dee7594 Update tox-bootstrapd's base Docker images
a030cdee5c Fix Docker tox-bootstrapd hash update failing when using BuildKit
7cfe35dff2 cleanup: Remove explicit layering_check feature.
d390947245 chore: Upgrade sonar-scan jvm to java 17.
d1e850c56c fix: Add missing `htons` call when adding configured TCP relay.
814090f2b8 chore: Cancel old PR builds on docker and sonar-scan workflows.
83efb17367 perf: Add a KVM FreeBSD build on cirrus ci.
a927183233 test: Add a test for encrypting 100MB of data.
28f39049f6 chore: Retry freebsd tests 2 times.
47e77d1bb0 chore: Use C99 on MSVC instead of C11.
7155f7f60e test: Add an s390x build (on alpine) for CI.
6c35cef63f chore: Add a compcert docker run script.
41e6ea865e cleanup: Use tcc docker image for CI.
e726b197b0 refactor: Store time in Mono_Time in milliseconds.
REVERT: d4b06edc2a feat: add ngc events

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: adbd5b32d85d9c13800f5ece17c0a9dce99faacd

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: Green-Sky

external/toxcore/CMakeLists.txt

@@ -91,6 +91,8 @@ add_library(toxcore STATIC
 	${TOX_DIR}toxcore/logger.h
 	${TOX_DIR}toxcore/Messenger.c
 	${TOX_DIR}toxcore/Messenger.h
+	${TOX_DIR}toxcore/mem.c
+	${TOX_DIR}toxcore/mem.h
 	${TOX_DIR}toxcore/mono_time.c
 	${TOX_DIR}toxcore/mono_time.h
 	${TOX_DIR}toxcore/net_crypto.c
@@ -153,6 +155,11 @@ configure_file(
 	${TOX_DIR}tox/tox_events.h
 	@ONLY
 )
+configure_file(
+	${TOX_DIR}toxcore/tox_private.h
+	${TOX_DIR}tox/tox_private.h
+	@ONLY
+)
 
 target_include_directories(toxcore PRIVATE "${TOX_DIR}toxcore")
 target_include_directories(toxcore PUBLIC "${TOX_DIR}")

external/toxcore/c-toxcore/.circleci/bazel-test

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -eux
+
+git submodule update --init --recursive
+/src/workspace/tools/inject-repo c-toxcore
+# TODO(iphydf): Re-enable fuzz-test when https://github.com/tweag/rules_nixpkgs/issues/442 is fixed.
+cd /src/workspace && bazel test -k \
+  --build_tag_filters=-haskell,-fuzz-test \
+  --test_tag_filters=-haskell,-fuzz-test \
+  -- \
+  "$@"

external/toxcore/c-toxcore/.circleci/cmake-ubsan

@@ -6,6 +6,7 @@ CACHEDIR="$HOME/cache"
 
 . ".github/scripts/flags-$CC.sh"
 add_flag -Werror
+add_flag -D_DEBUG
 add_flag -fdiagnostics-color=always
 add_flag -fno-omit-frame-pointer
 add_flag -fno-sanitize-recover=all

external/toxcore/c-toxcore/.circleci/config.yml

@@ -5,10 +5,13 @@ workflows:
   version: 2
   program-analysis:
     jobs:
-      # Dynamic analysis
+      # Dynamic analysis in the Bazel build
+      - bazel-asan
+      - bazel-msan
+      - bazel-tsan
+      # Dynamic analysis with CMake
       - asan
       - tsan
-      - msan
       - ubsan
       # Static analysis
       - clang-analyze
@@ -18,6 +21,40 @@ workflows:
       - static-analysis
 
 jobs:
+  bazel-asan:
+    working_directory: /tmp/cirrus-ci-build
+    docker:
+      - image: toxchat/toktok-stack:latest-asan
+
+    steps:
+      - checkout
+      - run: .circleci/bazel-test
+          //c-toxcore/...
+
+  bazel-tsan:
+    working_directory: /tmp/cirrus-ci-build
+    docker:
+      - image: toxchat/toktok-stack:latest-tsan
+
+    steps:
+      - checkout
+      - run: .circleci/bazel-test
+          //c-toxcore/...
+          -//c-toxcore/auto_tests:conference_av_test
+          -//c-toxcore/auto_tests:conference_test
+          -//c-toxcore/auto_tests:onion_test
+          -//c-toxcore/auto_tests:tox_many_test
+
+  bazel-msan:
+    working_directory: /tmp/cirrus-ci-build
+    docker:
+      - image: toxchat/toktok-stack:latest-msan
+
+    steps:
+      - checkout
+      - run: .circleci/bazel-test
+          //c-toxcore/auto_tests:lossless_packet_test
+
   asan:
     working_directory: ~/work
     docker:
@@ -66,21 +103,6 @@ jobs:
       - run: git submodule update --init --recursive
       - run: CC=clang .circleci/cmake-ubsan
 
-  msan:
-    working_directory: ~/work
-    docker:
-      - image: toxchat/toktok-stack:latest-msan
-
-    steps:
-      - checkout
-      - run: git submodule update --init --recursive
-      - run: rm -rf /src/workspace/c-toxcore/* && mv * /src/workspace/c-toxcore/
-      - run:
-          cd /src/workspace && bazel test
-            //c-toxcore/auto_tests:lossless_packet_test
-            //c-toxcore/toxav/...
-            //c-toxcore/toxcore/...
-
   infer:
     working_directory: ~/work
     docker:
@@ -144,10 +166,9 @@ jobs:
       - run:
           apt-get install -y --no-install-recommends
             ca-certificates
-            clang-tidy-12
+            clang-tidy-14
       - checkout
       - run: git submodule update --init --recursive
-      - run: cmake . -B_build -GNinja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
       - run:
           other/analysis/run-clang-tidy ||
           other/analysis/run-clang-tidy ||

external/toxcore/c-toxcore/.cirrus.yml

@@ -9,10 +9,8 @@ bazel-opt_task:
     - /src/workspace/tools/inject-repo c-toxcore
   test_all_script:
     - cd /src/workspace && bazel test -k
-        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
         --build_tag_filters=-haskell
         --test_tag_filters=-haskell
-        --remote_download_minimal
         --
         //c-toxcore/...
         -//c-toxcore/auto_tests:tcp_relay_test # TODO(robinlinden): Why does this pass locally but not in Cirrus?
@@ -27,76 +25,12 @@ bazel-dbg_task:
     - /src/workspace/tools/inject-repo c-toxcore
   test_all_script:
     - cd /src/workspace && bazel test -k
-        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
         --build_tag_filters=-haskell
         --test_tag_filters=-haskell
-        --remote_download_minimal
         --
         //c-toxcore/...
         -//c-toxcore/auto_tests:tcp_relay_test # TODO(robinlinden): Why does this pass locally but not in Cirrus?
 
-bazel-asan_task:
-  container:
-    image: toxchat/toktok-stack:latest-asan
-    cpu: 2
-    memory: 4G
-  configure_script:
-    - git submodule update --init --recursive
-    - /src/workspace/tools/inject-repo c-toxcore
-  test_all_script:
-    - cd /src/workspace && bazel test -k
-        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
-        --build_tag_filters=-haskell
-        --test_tag_filters=-haskell
-        --remote_download_minimal
-        --
-        //c-toxcore/...
-        -//c-toxcore/auto_tests:tcp_relay_test # TODO(robinlinden): Why does this pass locally but not in Cirrus?
-
-# TODO(iphydf): Enable once this works properly.
-#bazel-msan_task:
-#  container:
-#    image: toxchat/toktok-stack:latest-msan
-#    cpu: 2
-#    memory: 4G
-#  configure_script:
-#    - git submodule update --init --recursive
-#    - /src/workspace/tools/inject-repo c-toxcore
-#  test_all_script:
-#    - cd /src/workspace && bazel test -k
-#        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
-#        --build_tag_filters=-haskell
-#        --test_tag_filters=-haskell
-#        --remote_download_minimal
-#        --
-#        //c-toxcore/...
-#        -//c-toxcore/auto_tests:tcp_relay_test # TODO(robinlinden): Why does this pass locally but not in Cirrus?
-
-# TODO(iphydf): Fix test timeouts.
-bazel-tsan_task:
-  container:
-    image: toxchat/toktok-stack:latest-tsan
-    cpu: 2
-    memory: 4G
-  configure_script:
-    - git submodule update --init --recursive
-    - /src/workspace/tools/inject-repo c-toxcore
-  test_all_script:
-    - cd /src/workspace && bazel test -k
-        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
-        --build_tag_filters=-haskell
-        --test_tag_filters=-haskell
-        --remote_download_minimal
-        --
-        //c-toxcore/...
-        -//c-toxcore/auto_tests:conference_av_test
-        -//c-toxcore/auto_tests:conference_test
-        -//c-toxcore/auto_tests:file_transfer_test
-        -//c-toxcore/auto_tests:group_tcp_test
-        -//c-toxcore/auto_tests:onion_test
-        -//c-toxcore/auto_tests:tcp_relay_test
-        -//c-toxcore/auto_tests:tox_many_test
-
 cimple_task:
   container:
     image: toxchat/toktok-stack:latest-release
@@ -107,8 +41,19 @@ cimple_task:
     - /src/workspace/tools/inject-repo c-toxcore
   test_all_script:
     - cd /src/workspace && bazel test -k
-        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
         --build_tag_filters=haskell
         --test_tag_filters=haskell
         --
         //c-toxcore/...
+
+freebsd_task:
+  container:
+    image: toxchat/freebsd:latest
+    cpu: 2
+    memory: 4G
+    kvm: true
+  configure_script:
+    - git submodule update --init --recursive
+    - cd .. && mv cirrus-ci-build /work/c-toxcore && mkdir cirrus-ci-build
+  test_all_script:
+    - cd /work/c-toxcore && .github/scripts/cmake-freebsd

external/toxcore/c-toxcore/.clang-tidy

@@ -0,0 +1,40 @@
+# vim:ft=yaml
+CheckOptions:
+  - key:             readability-identifier-naming.ClassCase
+    value:           Camel_Snake_Case
+  - key:             readability-identifier-naming.ConstantCase
+    value:           lower_case
+  # bootstrap-daemon has these.
+  - key:             readability-identifier-naming.ConstantIgnoredRegexp
+    value:           "^NAME_.*"
+  - key:             readability-identifier-naming.EnumCase
+    value:           Camel_Snake_Case
+  - key:             readability-identifier-naming.EnumConstantCase
+    value:           UPPER_CASE
+  - key:             readability-identifier-naming.FunctionCase
+    value:           lower_case
+  - key:             readability-identifier-naming.GlobalConstantCase
+    value:           lower_case
+  - key:             readability-identifier-naming.MemberCase
+    value:           lower_case
+  - key:             readability-identifier-naming.MacroDefinitionCase
+    value:           UPPER_CASE
+  - key:             readability-identifier-naming.MacroDefinitionIgnoredRegexp
+    value:           "^_.*|nullable|non_null|nullptr|static_assert|ck_.*"
+  - key:             readability-identifier-naming.ParameterCase
+    value:           lower_case
+  - key:             readability-identifier-naming.StructCase
+    value:           Camel_Snake_Case
+  - key:             readability-identifier-naming.TypedefCase
+    value:           Camel_Snake_Case
+  - key:             readability-identifier-naming.TypedefIgnoredRegexp
+    value:           ".*_cb"
+  - key:             readability-identifier-naming.UnionCase
+    value:           Camel_Snake_Case
+  - key:             readability-identifier-naming.VariableCase
+    value:           lower_case
+
+  - key:             llvmlibc-restrict-system-libc-headers.Includes
+    value:           "arpa/inet.h,assert.h,ctype.h,errno.h,fcntl.h,getopt.h,libconfig.h,linux/netdevice.h,math.h,netdb.h,netinet/in.h,opus.h,pthread.h,signal.h,sodium/crypto_scalarmult_curve25519.h,sodium.h,sodium/randombytes.h,stdio.h,stdlib.h,string.h,sys/ioctl.h,syslog.h,sys/resource.h,sys/socket.h,sys/stat.h,sys/time.h,sys/types.h,time.h,unistd.h,vpx/vp8cx.h,vpx/vp8dx.h,vpx/vpx_decoder.h,vpx/vpx_encoder.h,vpx/vpx_image.h"
+  - key:             hicpp-signed-bitwise.IgnorePositiveIntegerLiterals
+    value:           true

external/toxcore/c-toxcore/.devcontainer/devcontainer.json

@@ -0,0 +1,11 @@
+{
+	"image": "mcr.microsoft.com/devcontainers/universal:2",
+	"features": {
+		"ghcr.io/devcontainers-contrib/features/bash-command:1": {
+			"command": "git submodule update --init --recursive"
+		},
+		"ghcr.io/devcontainers-contrib/features/apt-packages:1": {
+			"packages": "libconfig-dev,libopus-dev,libvpx-dev,ninja-build"
+		}
+	}
+}

external/toxcore/c-toxcore/.dockerignore

@@ -0,0 +1,2 @@
+/_build
+/_install

external/toxcore/c-toxcore/.github/scripts/cmake-alpine-s390x

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Copyright (C) 2018-2023 nurupo
+
+# Toxcore building
+
+set -eux
+
+cd .. # /work
+. cmake-alpine-run.sh
+
+# === Get VM ready to build the code ===
+
+start_vm
+
+RUN apk add cmake g++ ninja
+
+mv c-toxcore /
+
+# Copy over toxcore code from host to qemu
+scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -P "$SSH_PORT" -r /c-toxcore root@localhost:~
+
+cd /c-toxcore
+. ".github/scripts/flags-gcc.sh"
+
+# Make compilation error on a warning
+add_flag -Werror
+
+# - disabling toxav because vpx doesn't work on s390x.
+# - disabling bootstrap daemons because we don't need them for testing (saving time).
+# - disabling shared libraries because it saves a lot of time on building PIC objects.
+# - enable unity build because it saves a lot of time as well (fewer objects to build).
+RUN "cmake -B_build -Hc-toxcore -GNinja \
+  -DCMAKE_C_FLAGS='$C_FLAGS' \
+  -DCMAKE_CXX_FLAGS='$CXX_FLAGS' \
+  -DCMAKE_EXE_LINKER_FLAGS='$LD_FLAGS' \
+  -DCMAKE_SHARED_LINKER_FLAGS='$LD_FLAGS' \
+  -DCMAKE_INSTALL_PREFIX:PATH='_install' \
+  -DCMAKE_UNITY_BUILD=ON \
+  -DMIN_LOGGER_LEVEL=TRACE \
+  -DNON_HERMETIC_TESTS=ON \
+  -DENABLE_SHARED=OFF \
+  -DBUILD_TOXAV=OFF \
+  -DDHT_BOOTSTRAP=OFF \
+  -DBOOTSTRAP_DAEMON=OFF \
+  -DSTRICT_ABI=ON \
+  -DTEST_TIMEOUT_SECONDS=90 \
+  -DUSE_IPV6=OFF \
+  -DAUTOTEST=ON"
+
+RUN 'cmake --build _build --parallel 2 --target install -- -k 0'
+RUN 'cd _build && ctest -j50 --output-on-failure --rerun-failed --repeat until-pass:1 --timeout 90 || true' &
+
+# Give the tests 5 minutes to run. Sometimes, the per-test timeout doesn't
+# work, so we put a global timeout here for everything.
+sleep 300

external/toxcore/c-toxcore/.github/scripts/cmake-android

@@ -10,7 +10,7 @@ ABI=${1:-"armeabi-v7a"}
 case $ABI in
   armeabi-v7a)
     TARGET=armv7a-linux-androideabi
-    NDK_API=16
+    NDK_API=19
     ;;
   arm64-v8a)
     TARGET=aarch64-linux-android
@@ -18,7 +18,7 @@ case $ABI in
     ;;
   x86)
     TARGET=i686-linux-android
-    NDK_API=16
+    NDK_API=19
     ;;
   x86_64)
     TARGET=x86_64-linux-android
@@ -47,7 +47,7 @@ fi
 cd libsodium
 git clean -ffdx
 autoreconf -fi
-./configure --prefix="$PREFIX" --host="$TARGET" --with-sysroot="$SYSROOT" --disable-shared
+./configure --prefix="$PREFIX" --host="$TARGET" --with-sysroot="$SYSROOT" --disable-shared --disable-pie
 make -j"$(nproc)" install
 cd ..
 

external/toxcore/c-toxcore/.github/scripts/cmake-freebsd

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Copyright (C) 2018-2023 nurupo
+
+# Toxcore building
+
+set -eux
+
+cd .. # /work
+. cmake-freebsd-run.sh
+
+# === Get VM ready to build the code ===
+
+# Unpack image only if it's compressed.
+if [ -f "$IMAGE_NAME.gz" ]; then
+  gunzip "$IMAGE_NAME.gz"
+fi
+
+mv c-toxcore /
+
+start_vm
+
+# Copy over toxcore code from host to qemu
+scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -P "$SSH_PORT" -r /c-toxcore root@localhost:~
+
+RUN ls -lh
+
+cd /c-toxcore
+. '.github/scripts/flags-clang.sh'
+
+add_ld_flag -Wl,-z,defs
+
+# Make compilation error on a warning.
+add_flag -Werror
+
+# This triggers on FreeBSD's clang.
+add_flag -Wno-format
+add_flag -Wno-unsafe-buffer-usage
+
+RUN "cmake -B_build -Hc-toxcore \
+  -DCMAKE_C_FLAGS='$C_FLAGS' \
+  -DCMAKE_CXX_FLAGS='$CXX_FLAGS' \
+  -DCMAKE_EXE_LINKER_FLAGS='$LD_FLAGS' \
+  -DCMAKE_SHARED_LINKER_FLAGS='$LD_FLAGS' \
+  -DCMAKE_INSTALL_PREFIX:PATH='_install' \
+  -DMIN_LOGGER_LEVEL=TRACE \
+  -DMUST_BUILD_TOXAV=ON \
+  -DNON_HERMETIC_TESTS=ON \
+  -DSTRICT_ABI=ON \
+  -DTEST_TIMEOUT_SECONDS=120 \
+  -DUSE_IPV6=OFF \
+  -DAUTOTEST=ON"
+
+# We created the VM with the same number of cores as the host, so the host-ran `nproc` here is fine.
+RUN 'cmake --build _build --parallel "$NPROC" --target install -- -k'
+RUN 'cd _build && ctest -j50 --output-on-failure --rerun-failed --repeat until-pass:2 --timeout 120 || true'
+
+# Gracefully shut down the VM.
+stop_vm

external/toxcore/c-toxcore/.github/scripts/cmake-freebsd-stage2

@@ -1,52 +0,0 @@
-#!/bin/bash
-# Copyright (C) 2018-2021 nurupo
-
-# Toxcore building
-
-set -eux
-
-if [ "$PWD" != "/work" ]; then
-  cd ..
-  mv c-toxcore /
-  mkdir c-toxcore
-  cd /work
-fi
-
-. cmake-freebsd-run.sh
-
-# === Get VM ready to build the code ===
-
-gunzip "$IMAGE_NAME.gz"
-
-start_vm
-
-# Copy over toxcore code from host to qemu
-scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -P "$SSH_PORT" -r /c-toxcore root@localhost:~
-
-RUN ls -lh
-
-cd /c-toxcore
-. ".github/scripts/flags-clang.sh"
-
-add_ld_flag -Wl,-z,defs
-
-# Make compilation error on a warning
-add_flag -Werror
-
-RUN 'cmake -B_build -Hc-toxcore \
-  -DCMAKE_C_FLAGS="$C_FLAGS" \
-  -DCMAKE_CXX_FLAGS="$CXX_FLAGS" \
-  -DCMAKE_EXE_LINKER_FLAGS="$LD_FLAGS" \
-  -DCMAKE_SHARED_LINKER_FLAGS="$LD_FLAGS" \
-  -DCMAKE_INSTALL_PREFIX:PATH="_install" \
-  -DMIN_LOGGER_LEVEL=TRACE \
-  -DMUST_BUILD_TOXAV=ON \
-  -DNON_HERMETIC_TESTS=ON \
-  -DSTRICT_ABI=ON \
-  -DTEST_TIMEOUT_SECONDS=90 \
-  -DUSE_IPV6=OFF \
-  -DAUTOTEST=ON'
-
-# We created the VM with the same number of cores as the host, so the host-ran `nproc` here is fine
-RUN 'gmake "-j$NPROC" -k install -C_build'
-RUN 'gmake "-j$NPROC" test ARGS="-j50" -C_build || true'

external/toxcore/c-toxcore/.github/scripts/coverage-linux

@@ -9,7 +9,7 @@ sudo apt-get install -y --no-install-recommends \
   libopus-dev \
   libsodium-dev \
   libvpx-dev \
-  llvm-11 \
+  llvm-14 \
   ninja-build
 git clone --depth=1 https://github.com/ralight/mallocfail /tmp/mallocfail
 cd /tmp/mallocfail # pushd
@@ -21,7 +21,7 @@ export CC=clang
 export CXX=clang++
 
 sudo install other/docker/coverage/run_mallocfail /usr/local/bin/run_mallocfail
-(cd other/proxy && go build)
+(cd other/proxy && go get && go build)
 other/proxy/proxy &
 
 . ".github/scripts/flags-coverage.sh"
@@ -58,4 +58,4 @@ cd - # popd
 #  --exclude testing \
 #  --gcov-options '\-lp'
 
-bash <(curl -s https://codecov.io/bash) -x "llvm-cov-11 gcov"
+bash <(curl -s https://codecov.io/bash) -x "llvm-cov-14 gcov"

external/toxcore/c-toxcore/.github/scripts/flags.sh

@@ -28,8 +28,6 @@ add_flag -O3 -march=native
 
 # Warn on non-ISO C.
 add_c_flag -pedantic
-add_c_flag -std=c99
-add_cxx_flag -std=c++11
 
 add_flag -g3
 add_flag -ftrapv

external/toxcore/c-toxcore/.github/settings.yml

@@ -12,36 +12,52 @@ branches:
     protection:
       required_status_checks:
         contexts:
-          - "bazel-asan"
           - "bazel-dbg"
           - "bazel-opt"
-          - "bazel-tsan"
+          - "build-alpine-s390x"
+          - "build-android"
           - "build-compcert"
           - "build-macos"
           - "build-nacl"
           - "build-tcc"
           - "build-win32"
           - "build-win64"
-          - "CodeFactor"
-          - "common / buildifier"
-          - "coverage-linux"
           - "ci/circleci: asan"
+          - "ci/circleci: bazel-asan"
+          - "ci/circleci: bazel-msan"
+          - "ci/circleci: bazel-tsan"
           - "ci/circleci: clang-analyze"
           - "ci/circleci: clang-tidy"
           - "ci/circleci: cpplint"
           - "ci/circleci: infer"
-          - "ci/circleci: msan"
           - "ci/circleci: static-analysis"
           - "ci/circleci: tsan"
           - "ci/circleci: ubsan"
           - "cimple"
+          - "cimplefmt"
+          - "CodeFactor"
           - "code-review/reviewable"
-          - "continuous-integration/appveyor/pr"
+          - "common / buildifier"
+          - "coverage-linux"
           - "docker-bootstrap-node"
           - "docker-bootstrap-node-websocket"
+          - "docker-clusterfuzz"
+          - "docker-esp32"
+          - "docker-fuzzer"
           - "docker-toxcore-js"
+          - "docker-win32"
+          - "docker-win64"
+          - "doxygen"
+          - "freebsd"
+          - "Hound"
+          - "misra"
           - "mypy"
+          - "program-analysis"
           - "sonar-scan"
+          - "tokstyle"
+          - "TokTok.c-toxcore"
+          - "TokTok.c-toxcore (windows_msvc_conan shared)"
+          - "TokTok.c-toxcore (windows_msvc_conan static)"
 
 # Labels specific to c-toxcore.
 labels:

external/toxcore/c-toxcore/.github/workflows/ci.yml

@@ -60,15 +60,6 @@ jobs:
         with:
           file: other/docker/misra/Dockerfile
 
-  cimplefmt:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Run cimplefmt
-        run: other/docker/cimplefmt/run -u $(find tox* -name "*.[ch]")
-
   build-nacl:
     runs-on: ubuntu-latest
     steps:
@@ -79,6 +70,45 @@ jobs:
         with:
           file: other/docker/autotools/Dockerfile
 
+  build-tcc:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Docker Build
+        uses: docker/build-push-action@v2
+        with:
+          file: other/docker/tcc/Dockerfile
+
+  build-compcert:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Docker Build
+        uses: docker/build-push-action@v2
+        with:
+          file: other/docker/compcert/Dockerfile
+
+  build-alpine-s390x:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+      - name: Docker Build
+        uses: docker/build-push-action@v2
+        with:
+          file: other/docker/alpine-s390x/Dockerfile
+
+  cimplefmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Run cimplefmt
+        run: other/docker/cimplefmt/run -u $(find tox* -name "*.[ch]")
+
   build-win32:
     runs-on: ubuntu-latest
     steps:
@@ -97,16 +127,6 @@ jobs:
       - name: Cross compilation
         run: .github/scripts/cmake-win64 script
 
-  build-freebsd:
-    runs-on: ubuntu-latest
-    container: toxchat/freebsd
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Build on FreeBSD
-        run: .github/scripts/cmake-freebsd-stage2
-
   build-macos:
     runs-on: macos-latest
     steps:
@@ -125,81 +145,6 @@ jobs:
       - name: Build, test, and upload coverage
         run: .github/scripts/coverage-linux
 
-  build-tcc:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Install dependencies
-        run:
-          sudo apt-get install -y --no-install-recommends
-            tcc
-            libconfig-dev
-            libopus-dev
-            libsodium-dev
-            libvpx-dev
-      - name: Build with TCC
-        run:
-          tcc
-            -Dinline=static
-            -o send_message_test
-            -Wall -Werror
-            -bench -g
-            auto_tests/auto_test_support.c
-            auto_tests/send_message_test.c
-            testing/misc_tools.c
-            toxav/*.c
-            toxcore/*.c
-            toxcore/*/*.c
-            toxencryptsave/*.c
-            third_party/cmp/*.c
-            $(pkg-config --cflags --libs libsodium opus vpx)
-      - name: Run the test
-        run: "./send_message_test | grep 'tox clients connected'"
-      - name: Build amalgamation file with TCC
-        run:
-          other/make_single_file
-            auto_tests/auto_test_support.c
-            auto_tests/send_message_test.c
-            testing/misc_tools.c |
-          tcc -
-            -o send_message_test
-            -Wall -Werror
-            -bench -g
-            $(pkg-config --cflags --libs libsodium opus vpx)
-      - name: Run the test again
-        run: "./send_message_test | grep 'tox clients connected'"
-
-  build-compcert:
-    runs-on: ubuntu-latest
-    container: toxchat/compcert
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Build with CompCert
-        run:
-          ccomp
-            -o send_message_test
-            -Wall -Werror
-            -Wno-c11-extensions
-            -Wno-unknown-pragmas
-            -Wno-unused-variable
-            -fstruct-passing -fno-unprototyped -g
-            auto_tests/auto_test_support.c
-            auto_tests/send_message_test.c
-            testing/misc_tools.c
-            toxav/*.c
-            toxcore/*.c
-            toxcore/*/*.c
-            toxencryptsave/*.c
-            third_party/cmp/*.c
-            -D__COMPCERT__ -DDISABLE_VLA -Dinline=
-            -lpthread $(pkg-config --cflags --libs libsodium opus vpx)
-      - name: Run the test
-        run: "./send_message_test | grep 'tox clients connected'"
-
   build-android:
     runs-on: ubuntu-latest
     steps:

external/toxcore/c-toxcore/.github/workflows/docker.yml

@@ -6,6 +6,11 @@ on:
   pull_request:
     branches: [master]
 
+# Cancel old PR builds when pushing new commits.
+concurrency:
+  group: docker-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   docker-bootstrap-node:
     runs-on: ubuntu-latest

external/toxcore/c-toxcore/.github/workflows/sonar-scan.yml

@@ -6,11 +6,16 @@ on:
   pull_request:
     branches: [master]
 
+# Cancel old PR builds when pushing new commits.
+concurrency:
+  group: scan-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   sonar-scan:
     runs-on: ubuntu-latest
     env:
-      SONAR_SCANNER_VERSION: 4.4.0.2170
+      SONAR_SCANNER_VERSION: 5.0.1.3006
       SONAR_SERVER_URL: "https://sonarcloud.io"
       BUILD_WRAPPER_OUT_DIR: build_wrapper_output_directory # Directory where build-wrapper output will be placed
     steps:
@@ -18,10 +23,10 @@ jobs:
         with:
           fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
           submodules: recursive
-      - name: Set up JDK 11
+      - name: Set up JDK 17
         uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Download and set up sonar-scanner
         env:
           SONAR_SCANNER_DOWNLOAD_URL: https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-${{ env.SONAR_SCANNER_VERSION }}-linux.zip

external/toxcore/c-toxcore/BUILD.bazel

@@ -1,8 +1,6 @@
 load("@rules_cc//cc:defs.bzl", "cc_library")
 load("//tools/project:build_defs.bzl", "project")
 
-package(features = ["layering_check"])
-
 project()
 
 genrule(
@@ -10,16 +8,19 @@ genrule(
     srcs = [
         "//c-toxcore/toxav:toxav.h",
         "//c-toxcore/toxcore:tox.h",
+        "//c-toxcore/toxcore:tox_private.h",
         "//c-toxcore/toxencryptsave:toxencryptsave.h",
     ],
     outs = [
         "tox/toxav.h",
         "tox/tox.h",
+        "tox/tox_private.h",
         "tox/toxencryptsave.h",
     ],
     cmd = """
         cp $(location //c-toxcore/toxav:toxav.h) $(GENDIR)/c-toxcore/tox/toxav.h
         cp $(location //c-toxcore/toxcore:tox.h) $(GENDIR)/c-toxcore/tox/tox.h
+        cp $(location //c-toxcore/toxcore:tox_private.h) $(GENDIR)/c-toxcore/tox/tox_private.h
         cp $(location //c-toxcore/toxencryptsave:toxencryptsave.h) $(GENDIR)/c-toxcore/tox/toxencryptsave.h
     """,
     visibility = ["//visibility:public"],

external/toxcore/c-toxcore/CMakeLists.txt

@@ -14,8 +14,8 @@
 #
 ################################################################################
 
-cmake_minimum_required(VERSION 2.8.12)
-cmake_policy(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)
+cmake_policy(VERSION 3.5)
 project(toxcore)
 
 list(APPEND CMAKE_MODULE_PATH ${toxcore_SOURCE_DIR}/cmake)
@@ -79,21 +79,19 @@ enable_testing()
 
 set(CMAKE_MACOSX_RPATH ON)
 
-if(${CMAKE_VERSION} VERSION_LESS "3.1.0")
-  if(NOT MSVC)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-  endif()
-else()
-  # Set standard version for compiler.
+# Set standard version for compiler.
+if(MSVC)
+  # https://developercommunity.visualstudio.com/t/older-winsdk-headers-are-incompatible-with-zcprepr/1593479
   set(CMAKE_C_STANDARD 99)
-  set(CMAKE_CXX_STANDARD 17)
-  set(CMAKE_C_EXTENSIONS OFF)
-  set(CMAKE_CXX_EXTENSIONS OFF)
-
-  message(STATUS "Supported C compiler features = ${CMAKE_C_COMPILE_FEATURES}")
-  message(STATUS "Supported C++ compiler features = ${CMAKE_CXX_COMPILE_FEATURES}")
+else()
+  set(CMAKE_C_STANDARD 11)
 endif()
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_C_EXTENSIONS OFF)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+message(STATUS "Supported C compiler features = ${CMAKE_C_COMPILE_FEATURES}")
+message(STATUS "Supported C++ compiler features = ${CMAKE_CXX_COMPILE_FEATURES}")
 
 set(MIN_LOGGER_LEVEL "" CACHE STRING "Logging level to use (TRACE, DEBUG, INFO, WARNING, ERROR)")
 if(MIN_LOGGER_LEVEL)
@@ -156,7 +154,7 @@ endif()
 if(MSVC)
   option(MSVC_STATIC_SODIUM "Whether to link libsodium statically for MSVC" OFF)
   if(MSVC_STATIC_SODIUM)
-    add_definitions(-DSODIUM_STATIC=1 -DSODIUM_EXPORT)
+    add_definitions(-DSODIUM_STATIC=1)
   endif()
 endif()
 
@@ -286,6 +284,8 @@ set(toxcore_SOURCES
   toxcore/logger.h
   toxcore/Messenger.c
   toxcore/Messenger.h
+  toxcore/mem.c
+  toxcore/mem.h
   toxcore/mono_time.c
   toxcore/mono_time.h
   toxcore/net_crypto.c
@@ -334,7 +334,8 @@ set(toxcore_PKGCONFIG_REQUIRES ${toxcore_PKGCONFIG_REQUIRES} libsodium)
 set(toxcore_API_HEADERS
   ${toxcore_SOURCE_DIR}/toxcore/tox.h^tox
   ${toxcore_SOURCE_DIR}/toxcore/tox_events.h^tox
-  ${toxcore_SOURCE_DIR}/toxcore/tox_dispatch.h^tox)
+  ${toxcore_SOURCE_DIR}/toxcore/tox_dispatch.h^tox
+  ${toxcore_SOURCE_DIR}/toxcore/tox_private.h^tox)
 
 ################################################################################
 #
@@ -452,6 +453,7 @@ unit_test(toxcore bin_pack)
 unit_test(toxcore crypto_core)
 unit_test(toxcore group_announce)
 unit_test(toxcore group_moderation)
+unit_test(toxcore mem)
 unit_test(toxcore mono_time)
 unit_test(toxcore ping_array)
 unit_test(toxcore tox)

external/toxcore/c-toxcore/README.md

@@ -4,8 +4,6 @@
 
 [**Website**](https://tox.chat) **|** [**Wiki**](https://wiki.tox.chat/) **|** [**Blog**](https://blog.tox.chat/) **|** [**FAQ**](https://wiki.tox.chat/doku.php?id=users:faq) **|** [**Binaries/Downloads**](https://tox.chat/download.html) **|** [**Clients**](https://wiki.tox.chat/doku.php?id=clients) **|** [**Compiling**](/INSTALL.md)
 
-**IRC Channels:** Users: [#tox@libera.chat](https://web.libera.chat/#tox), Developers: [#toktok@libera.chat](https://web.libera.chat/#toktok)
-
 ## What is Tox
 
 Tox is a peer to peer (serverless) instant messenger aimed at making security

external/toxcore/c-toxcore/appveyor.yml

@@ -1,32 +0,0 @@
----
-image: Visual Studio 2019
-
-cache:
-  - '%USERPROFILE%\.conan -> conanfile.py'
-
-environment:
-  matrix:
-    - job_name: static
-    - job_name: shared
-
-install:
-  - set PATH=C:\Python311-x64\Scripts;%PATH%
-  - py -3 -m pip install conan==1.59.0
-  - git submodule update --init --recursive
-
-for:
-  - matrix:
-      only:
-        - job_name: static
-    before_build:
-      - conan install -if _build -o with_tests=False .
-  - matrix:
-      only:
-        - job_name: shared
-    before_build:
-      - conan install -if _build -o with_tests=False -o shared=True .
-
-build_script:
-  - set CONAN_CPU_COUNT=50
-  - set CTEST_OUTPUT_ON_FAILURE=1
-  - conan build -bf _build -if _build .

external/toxcore/c-toxcore/auto_tests/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
 
-package(features = ["layering_check"])
-
 cc_library(
     name = "check_compat",
     testonly = True,
@@ -29,12 +27,26 @@ flaky_tests = {
     "tox_many_tcp_test": True,
 }
 
+extra_args = {
+    "proxy_test": ["$(location //c-toxcore/other/proxy)"],
+}
+
+extra_data = {
+    "proxy_test": ["//c-toxcore/other/proxy"],
+}
+
 [cc_test(
     name = src[:-2],
     size = "small",
     srcs = [src],
-    args = ["$(location %s)" % src] + ["$(location //c-toxcore/other/proxy)"],
-    data = glob(["data/*"]) + ["//c-toxcore/other/proxy"],
+    args = ["$(location %s)" % src] + extra_args.get(
+        src[:-2],
+        [],
+    ),
+    data = glob(["data/*"]) + extra_data.get(
+        src[:-2],
+        [],
+    ),
     flaky = flaky_tests.get(
         src[:-2],
         False,

external/toxcore/c-toxcore/auto_tests/TCP_test.c

@@ -34,20 +34,25 @@ static IP get_loopback(void)
     return ip;
 }
 
-static void do_TCP_server_delay(TCP_Server *tcp_s, Mono_Time *mono_time, int delay)
+static void do_tcp_server_delay(TCP_Server *tcp_s, Mono_Time *mono_time, int delay)
 {
     c_sleep(delay);
     mono_time_update(mono_time);
-    do_TCP_server(tcp_s, mono_time);
+    do_tcp_server(tcp_s, mono_time);
     c_sleep(delay);
 }
 static uint16_t ports[NUM_PORTS] = {13215, 33445, 25643};
 
 static void test_basic(void)
 {
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
+    const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
     Logger *logger = logger_new();
     logger_callback_log(logger, print_debug_logger, nullptr, nullptr);
 
@@ -55,8 +60,7 @@ static void test_basic(void)
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    const Network *ns = system_network();
-    TCP_Server *tcp_s = new_TCP_server(logger, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
+    TCP_Server *tcp_s = new_tcp_server(logger, mem, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
     ck_assert_msg(tcp_s != nullptr, "Failed to create a TCP relay server.");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS,
                   "Failed to bind a TCP relay server to all %d attempted ports.", NUM_PORTS);
@@ -70,7 +74,7 @@ static void test_basic(void)
     for (uint8_t i = 0; i < NUM_PORTS; i++) {
         sock = net_socket(ns, net_family_ipv6(), TOX_SOCK_STREAM, TOX_PROTO_TCP);
         localhost.port = net_htons(ports[i]);
-        bool ret = net_connect(logger, sock, &localhost);
+        bool ret = net_connect(mem, logger, sock, &localhost);
         ck_assert_msg(ret, "Failed to connect to created TCP relay server on port %d (%d).", ports[i], errno);
 
         // Leave open one connection for the next test.
@@ -110,14 +114,14 @@ static void test_basic(void)
                            &localhost) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "An attempt to send the initial handshake minus last byte failed.");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     ck_assert_msg(net_send(ns, logger, sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1, &localhost) == 1,
                   "The attempt to send the last byte of handshake failed.");
 
     free(handshake);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     // Receiving server response and decrypting it
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
@@ -157,7 +161,7 @@ static void test_basic(void)
 
         c_sleep(50);
         mono_time_update(mono_time);
-        do_TCP_server(tcp_s, mono_time);
+        do_tcp_server(tcp_s, mono_time);
     }
 
     // Receiving the second response and verifying its validity
@@ -181,33 +185,35 @@ static void test_basic(void)
 
     // Closing connections.
     kill_sock(ns, sock);
-    kill_TCP_server(tcp_s);
+    kill_tcp_server(tcp_s);
 
     logger_kill(logger);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
 }
 
 struct sec_TCP_con {
     Socket sock;
     const Network *ns;
+    const Memory *mem;
     uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t recv_nonce[CRYPTO_NONCE_SIZE];
     uint8_t sent_nonce[CRYPTO_NONCE_SIZE];
     uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 };
 
-static struct sec_TCP_con *new_TCP_con(const Logger *logger, const Random *rng, const Network *ns, TCP_Server *tcp_s, Mono_Time *mono_time)
+static struct sec_TCP_con *new_tcp_con(const Logger *logger, const Memory *mem, const Random *rng, const Network *ns, TCP_Server *tcp_s, Mono_Time *mono_time)
 {
     struct sec_TCP_con *sec_c = (struct sec_TCP_con *)malloc(sizeof(struct sec_TCP_con));
     ck_assert(sec_c != nullptr);
     sec_c->ns = ns;
+    sec_c->mem = mem;
     Socket sock = net_socket(ns, net_family_ipv6(), TOX_SOCK_STREAM, TOX_PROTO_TCP);
 
     IP_Port localhost;
     localhost.ip = get_loopback();
     localhost.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
 
-    bool ok = net_connect(logger, sock, &localhost);
+    bool ok = net_connect(mem, logger, sock, &localhost);
     ck_assert_msg(ok, "Failed to connect to the test TCP relay server.");
 
     uint8_t f_secret_key[CRYPTO_SECRET_KEY_SIZE];
@@ -231,12 +237,12 @@ static struct sec_TCP_con *new_TCP_con(const Logger *logger, const Random *rng,
                            &localhost) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "Failed to send the first portion of the handshake to the TCP relay server.");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     ck_assert_msg(net_send(ns, logger, sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1, &localhost) == 1,
                   "Failed to send last byte of handshake.");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
     uint8_t response_plain[TCP_HANDSHAKE_PLAIN_SIZE];
@@ -251,13 +257,13 @@ static struct sec_TCP_con *new_TCP_con(const Logger *logger, const Random *rng,
     return sec_c;
 }
 
-static void kill_TCP_con(struct sec_TCP_con *con)
+static void kill_tcp_con(struct sec_TCP_con *con)
 {
     kill_sock(con->ns, con->sock);
     free(con);
 }
 
-static int write_packet_TCP_test_connection(const Logger *logger, struct sec_TCP_con *con, const uint8_t *data,
+static int write_packet_tcp_test_connection(const Logger *logger, struct sec_TCP_con *con, const uint8_t *data,
         uint16_t length)
 {
     VLA(uint8_t, packet, sizeof(uint16_t) + length + CRYPTO_MAC_SIZE);
@@ -281,7 +287,7 @@ static int write_packet_TCP_test_connection(const Logger *logger, struct sec_TCP
     return 0;
 }
 
-static int read_packet_sec_TCP(const Logger *logger, struct sec_TCP_con *con, uint8_t *data, uint16_t length)
+static int read_packet_sec_tcp(const Logger *logger, struct sec_TCP_con *con, uint8_t *data, uint16_t length)
 {
     IP_Port localhost;
     localhost.ip = get_loopback();
@@ -297,44 +303,48 @@ static int read_packet_sec_TCP(const Logger *logger, struct sec_TCP_con *con, ui
 
 static void test_some(void)
 {
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
-    Logger *logger = logger_new();
     const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
+    Logger *logger = logger_new();
 
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Server *tcp_s = new_TCP_server(logger, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
+    TCP_Server *tcp_s = new_tcp_server(logger, mem, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
     ck_assert_msg(tcp_s != nullptr, "Failed to create TCP relay server");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS, "Failed to bind to all ports.");
 
-    struct sec_TCP_con *con1 = new_TCP_con(logger, rng, ns, tcp_s, mono_time);
-    struct sec_TCP_con *con2 = new_TCP_con(logger, rng, ns, tcp_s, mono_time);
-    struct sec_TCP_con *con3 = new_TCP_con(logger, rng, ns, tcp_s, mono_time);
+    struct sec_TCP_con *con1 = new_tcp_con(logger, mem, rng, ns, tcp_s, mono_time);
+    struct sec_TCP_con *con2 = new_tcp_con(logger, mem, rng, ns, tcp_s, mono_time);
+    struct sec_TCP_con *con3 = new_tcp_con(logger, mem, rng, ns, tcp_s, mono_time);
 
     uint8_t requ_p[1 + CRYPTO_PUBLIC_KEY_SIZE];
     requ_p[0] = TCP_PACKET_ROUTING_REQUEST;
 
     // Sending wrong public keys to test server response.
     memcpy(requ_p + 1, con3->public_key, CRYPTO_PUBLIC_KEY_SIZE);
-    write_packet_TCP_test_connection(logger, con1, requ_p, sizeof(requ_p));
+    write_packet_tcp_test_connection(logger, con1, requ_p, sizeof(requ_p));
     memcpy(requ_p + 1, con1->public_key, CRYPTO_PUBLIC_KEY_SIZE);
-    write_packet_TCP_test_connection(logger, con3, requ_p, sizeof(requ_p));
+    write_packet_tcp_test_connection(logger, con3, requ_p, sizeof(requ_p));
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     // Testing response from connection 1
     uint8_t data[2048];
-    int len = read_packet_sec_TCP(logger, con1, data, 2 + 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE);
+    int len = read_packet_sec_tcp(logger, con1, data, 2 + 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE, "Wrong response packet length of %d.", len);
     ck_assert_msg(data[0] == TCP_PACKET_ROUTING_RESPONSE, "Wrong response packet id of %d.", data[0]);
     ck_assert_msg(data[1] == 16, "Server didn't refuse connection using wrong public key.");
     ck_assert_msg(pk_equal(data + 2, con3->public_key), "Key in response packet wrong.");
 
     // Connection 3
-    len = read_packet_sec_TCP(logger, con3, data, 2 + 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con3, data, 2 + 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 1 + 1 + CRYPTO_PUBLIC_KEY_SIZE, "Wrong response packet length of %d.", len);
     ck_assert_msg(data[0] == TCP_PACKET_ROUTING_RESPONSE, "Wrong response packet id of %d.", data[0]);
     ck_assert_msg(data[1] == 16, "Server didn't refuse connection using wrong public key.");
@@ -342,67 +352,67 @@ static void test_some(void)
 
     uint8_t test_packet[512] = {16, 17, 16, 86, 99, 127, 255, 189, 78}; // What is this packet????
 
-    write_packet_TCP_test_connection(logger, con3, test_packet, sizeof(test_packet));
-    write_packet_TCP_test_connection(logger, con3, test_packet, sizeof(test_packet));
-    write_packet_TCP_test_connection(logger, con3, test_packet, sizeof(test_packet));
+    write_packet_tcp_test_connection(logger, con3, test_packet, sizeof(test_packet));
+    write_packet_tcp_test_connection(logger, con3, test_packet, sizeof(test_packet));
+    write_packet_tcp_test_connection(logger, con3, test_packet, sizeof(test_packet));
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    len = read_packet_sec_TCP(logger, con1, data, 2 + 2 + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con1, data, 2 + 2 + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 2, "wrong len %d", len);
     ck_assert_msg(data[0] == TCP_PACKET_CONNECTION_NOTIFICATION, "wrong packet id %u", data[0]);
     ck_assert_msg(data[1] == 16, "wrong peer id %u", data[1]);
-    len = read_packet_sec_TCP(logger, con3, data, 2 + 2 + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con3, data, 2 + 2 + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 2, "wrong len %d", len);
     ck_assert_msg(data[0] == TCP_PACKET_CONNECTION_NOTIFICATION, "wrong packet id %u", data[0]);
     ck_assert_msg(data[1] == 16, "wrong peer id %u", data[1]);
-    len = read_packet_sec_TCP(logger, con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(logger, con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(logger, con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con1, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    write_packet_TCP_test_connection(logger, con1, test_packet, sizeof(test_packet));
-    write_packet_TCP_test_connection(logger, con1, test_packet, sizeof(test_packet));
-    write_packet_TCP_test_connection(logger, con1, test_packet, sizeof(test_packet));
-    do_TCP_server_delay(tcp_s, mono_time, 50);
-    len = read_packet_sec_TCP(logger, con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
+    write_packet_tcp_test_connection(logger, con1, test_packet, sizeof(test_packet));
+    write_packet_tcp_test_connection(logger, con1, test_packet, sizeof(test_packet));
+    write_packet_tcp_test_connection(logger, con1, test_packet, sizeof(test_packet));
+    do_tcp_server_delay(tcp_s, mono_time, 50);
+    len = read_packet_sec_tcp(logger, con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(logger, con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
-    len = read_packet_sec_TCP(logger, con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
                   data[sizeof(test_packet) - 2], data[sizeof(test_packet) - 1]);
 
     uint8_t ping_packet[1 + sizeof(uint64_t)] = {TCP_PACKET_PING, 8, 6, 9, 67};
-    write_packet_TCP_test_connection(logger, con1, ping_packet, sizeof(ping_packet));
+    write_packet_tcp_test_connection(logger, con1, ping_packet, sizeof(ping_packet));
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    len = read_packet_sec_TCP(logger, con1, data, 2 + sizeof(ping_packet) + CRYPTO_MAC_SIZE);
+    len = read_packet_sec_tcp(logger, con1, data, 2 + sizeof(ping_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(ping_packet), "wrong len %d", len);
     ck_assert_msg(data[0] == TCP_PACKET_PONG, "wrong packet id %u", data[0]);
     ck_assert_msg(memcmp(ping_packet + 1, data + 1, sizeof(uint64_t)) == 0, "wrong packet data");
 
     // Kill off the connections
-    kill_TCP_server(tcp_s);
-    kill_TCP_con(con1);
-    kill_TCP_con(con2);
-    kill_TCP_con(con3);
+    kill_tcp_server(tcp_s);
+    kill_tcp_con(con1);
+    kill_tcp_con(con2);
+    kill_tcp_con(con3);
 
     logger_kill(logger);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
 }
 
 static int response_callback_good;
@@ -488,16 +498,20 @@ static int oob_data_callback(void *object, const uint8_t *public_key, const uint
 
 static void test_client(void)
 {
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
+    const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
     Logger *logger = logger_new();
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
 
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    const Network *ns = system_network();
-    TCP_Server *tcp_s = new_TCP_server(logger, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
+    TCP_Server *tcp_s = new_tcp_server(logger, mem, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
     ck_assert_msg(tcp_s != nullptr, "Failed to create a TCP relay server.");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS, "Failed to bind the relay server to all ports.");
 
@@ -509,9 +523,8 @@ static void test_client(void)
     ip_port_tcp_s.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
     ip_port_tcp_s.ip = get_loopback();
 
-    TCP_Client_Connection *conn = new_TCP_connection(logger, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f_public_key,
-                                  f_secret_key, nullptr);
-    do_TCP_connection(logger, mono_time, conn, nullptr);
+    TCP_Client_Connection *conn = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f_public_key, f_secret_key, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
     c_sleep(50);
 
     // The connection status should be unconfirmed here because we have finished
@@ -519,22 +532,22 @@ static void test_client(void)
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_UNCONFIRMED, "Wrong connection status. Expected: %d, is: %d.",
                   TCP_CLIENT_UNCONFIRMED, tcp_con_status(conn));
 
-    do_TCP_server_delay(tcp_s, mono_time, 50); // Now let the server handle requests...
+    do_tcp_server_delay(tcp_s, mono_time, 50); // Now let the server handle requests...
 
-    const uint8_t LOOP_SIZE = 3;
+    const uint8_t loop_size = 3;
 
-    for (uint8_t i = 0; i < LOOP_SIZE; i++) {
+    for (uint8_t i = 0; i < loop_size; i++) {
         mono_time_update(mono_time);
-        do_TCP_connection(logger, mono_time, conn, nullptr); // Run the connection loop.
+        do_tcp_connection(logger, mono_time, conn, nullptr); // Run the connection loop.
 
-        // The status of the connection should continue to be TCP_CLIENT_CONFIRMED after multiple subsequent do_TCP_connection() calls.
+        // The status of the connection should continue to be TCP_CLIENT_CONFIRMED after multiple subsequent do_tcp_connection() calls.
         ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_CONFIRMED, "Wrong connection status. Expected: %d, is: %d",
                       TCP_CLIENT_CONFIRMED, tcp_con_status(conn));
 
-        c_sleep(i == LOOP_SIZE - 1 ? 0 : 500); // Sleep for 500ms on all except third loop.
+        c_sleep(i == loop_size - 1 ? 0 : 500); // Sleep for 500ms on all except third loop.
     }
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     // And still after the server runs again.
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %d, is: %d", TCP_CLIENT_CONFIRMED,
@@ -544,7 +557,7 @@ static void test_client(void)
     uint8_t f2_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(rng, f2_public_key, f2_secret_key);
     ip_port_tcp_s.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
-    TCP_Client_Connection *conn2 = new_TCP_connection(logger, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f2_public_key,
+    TCP_Client_Connection *conn2 = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f2_public_key,
                                    f2_secret_key, nullptr);
 
     // The client should call this function (defined earlier) during the routing process.
@@ -559,13 +572,13 @@ static void test_client(void)
     // These integers will increment per successful callback.
     oob_data_callback_good = response_callback_good = status_callback_good = data_callback_good = 0;
 
-    do_TCP_connection(logger, mono_time, conn, nullptr);
-    do_TCP_connection(logger, mono_time, conn2, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn2, nullptr);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(logger, mono_time, conn, nullptr);
-    do_TCP_connection(logger, mono_time, conn2, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn2, nullptr);
     c_sleep(50);
 
     uint8_t data[5] = {1, 2, 3, 4, 5};
@@ -574,10 +587,10 @@ static void test_client(void)
     send_routing_request(logger, conn, f2_public_key);
     send_routing_request(logger, conn2, f_public_key);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(logger, mono_time, conn, nullptr);
-    do_TCP_connection(logger, mono_time, conn2, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn2, nullptr);
 
     // All callback methods save data should have run during the above network prodding.
     ck_assert_msg(oob_data_callback_good == 1, "OOB callback not called");
@@ -588,42 +601,46 @@ static void test_client(void)
     ck_assert_msg(status_callback_connection_id == response_callback_connection_id,
                   "Status and response callback connection IDs are not equal.");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     ck_assert_msg(send_data(logger, conn2, 0, data, 5) == 1, "Failed a send_data() call.");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(logger, mono_time, conn, nullptr);
-    do_TCP_connection(logger, mono_time, conn2, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn2, nullptr);
     ck_assert_msg(data_callback_good == 1, "Data callback was not called.");
     status_callback_good = 0;
     send_disconnect_request(logger, conn2, 0);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(logger, mono_time, conn, nullptr);
-    do_TCP_connection(logger, mono_time, conn2, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn2, nullptr);
     ck_assert_msg(status_callback_good == 1, "Status callback not called");
     ck_assert_msg(status_callback_status == 1, "Wrong status callback status.");
 
     // Kill off all connections and servers.
-    kill_TCP_server(tcp_s);
-    kill_TCP_connection(conn);
-    kill_TCP_connection(conn2);
+    kill_tcp_server(tcp_s);
+    kill_tcp_connection(conn);
+    kill_tcp_connection(conn2);
 
     logger_kill(logger);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
 }
 
 // Test how the client handles servers that don't respond.
 static void test_client_invalid(void)
 {
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
-    Logger *logger = logger_new();
     const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
+    Logger *logger = logger_new();
 
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
@@ -636,12 +653,12 @@ static void test_client_invalid(void)
 
     ip_port_tcp_s.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
     ip_port_tcp_s.ip = get_loopback();
-    TCP_Client_Connection *conn = new_TCP_connection(logger, mono_time, rng, ns, &ip_port_tcp_s,
+    TCP_Client_Connection *conn = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s,
                                                      self_public_key, f_public_key, f_secret_key, nullptr);
 
     // Run the client's main loop but not the server.
     mono_time_update(mono_time);
-    do_TCP_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
     c_sleep(50);
 
     // After 50ms of no response...
@@ -650,20 +667,20 @@ static void test_client_invalid(void)
     // After 5s...
     c_sleep(5000);
     mono_time_update(mono_time);
-    do_TCP_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_CONNECTING, "Wrong status. Expected: %d, is: %d.",
                   TCP_CLIENT_CONNECTING, tcp_con_status(conn));
     // 11s... (Should wait for 10 before giving up.)
     c_sleep(6000);
     mono_time_update(mono_time);
-    do_TCP_connection(logger, mono_time, conn, nullptr);
+    do_tcp_connection(logger, mono_time, conn, nullptr);
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_DISCONNECTED, "Wrong status. Expected: %d, is: %d.",
                   TCP_CLIENT_DISCONNECTED, tcp_con_status(conn));
 
-    kill_TCP_connection(conn);
+    kill_tcp_connection(conn);
 
     logger_kill(logger);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
 }
 
 #include "../toxcore/TCP_connection.h"
@@ -694,27 +711,31 @@ static int tcp_data_callback(void *object, int id, const uint8_t *data, uint16_t
 
 static void test_tcp_connection(void)
 {
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
-    Logger *logger = logger_new();
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
     const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
+    Logger *logger = logger_new();
 
     tcp_data_callback_called = 0;
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Server *tcp_s = new_TCP_server(logger, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
+    TCP_Server *tcp_s = new_tcp_server(logger, mem, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
     ck_assert_msg(pk_equal(tcp_server_public_key(tcp_s), self_public_key), "Wrong public key");
 
     TCP_Proxy_Info proxy_info;
     proxy_info.proxy_type = TCP_PROXY_NONE;
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Connections *tc_1 = new_tcp_connections(logger, rng, ns, mono_time, self_secret_key, &proxy_info);
+    TCP_Connections *tc_1 = new_tcp_connections(logger, mem, rng, ns, mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(pk_equal(tcp_connections_public_key(tc_1), self_public_key), "Wrong public key");
 
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Connections *tc_2 = new_tcp_connections(logger, rng, ns, mono_time, self_secret_key, &proxy_info);
+    TCP_Connections *tc_2 = new_tcp_connections(logger, mem, rng, ns, mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(pk_equal(tcp_connections_public_key(tc_2), self_public_key), "Wrong public key");
 
     IP_Port ip_port_tcp_s;
@@ -736,17 +757,17 @@ static void test_tcp_connection(void)
     ck_assert_msg(new_tcp_connection_to(tc_2, tcp_connections_public_key(tc_1), 123) == -1,
                   "Managed to read same connection\n");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
@@ -755,7 +776,7 @@ static void test_tcp_connection(void)
     ck_assert_msg(ret == 0, "could not send packet.");
     set_packet_tcp_connection_callback(tc_2, &tcp_data_callback, (void *) 120397);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
@@ -764,7 +785,7 @@ static void test_tcp_connection(void)
     ck_assert_msg(tcp_connection_to_online_tcp_relays(tc_1, 0) == 1, "Wrong number of connected relays");
     ck_assert_msg(kill_tcp_connection_to(tc_1, 0) == 0, "could not kill connection to\n");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
@@ -772,12 +793,12 @@ static void test_tcp_connection(void)
     ck_assert_msg(send_packet_tcp_connection(tc_1, 0, (const uint8_t *)"Gentoo", 6) == -1, "could send packet.");
     ck_assert_msg(kill_tcp_connection_to(tc_2, 0) == 0, "could not kill connection to\n");
 
-    kill_TCP_server(tcp_s);
+    kill_tcp_server(tcp_s);
     kill_tcp_connections(tc_1);
     kill_tcp_connections(tc_2);
 
     logger_kill(logger);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
 }
 
 static bool tcp_oobdata_callback_called;
@@ -803,11 +824,15 @@ static int tcp_oobdata_callback(void *object, const uint8_t *public_key, unsigne
 
 static void test_tcp_connection2(void)
 {
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
-    Logger *logger = logger_new();
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
     const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
+    Logger *logger = logger_new();
 
     tcp_oobdata_callback_called = 0;
     tcp_data_callback_called = 0;
@@ -815,17 +840,17 @@ static void test_tcp_connection2(void)
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Server *tcp_s = new_TCP_server(logger, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
+    TCP_Server *tcp_s = new_tcp_server(logger, mem, rng, ns, USE_IPV6, NUM_PORTS, ports, self_secret_key, nullptr, nullptr);
     ck_assert_msg(pk_equal(tcp_server_public_key(tcp_s), self_public_key), "Wrong public key");
 
     TCP_Proxy_Info proxy_info;
     proxy_info.proxy_type = TCP_PROXY_NONE;
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Connections *tc_1 = new_tcp_connections(logger, rng, ns, mono_time, self_secret_key, &proxy_info);
+    TCP_Connections *tc_1 = new_tcp_connections(logger, mem, rng, ns, mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(pk_equal(tcp_connections_public_key(tc_1), self_public_key), "Wrong public key");
 
     crypto_new_keypair(rng, self_public_key, self_secret_key);
-    TCP_Connections *tc_2 = new_tcp_connections(logger, rng, ns, mono_time, self_secret_key, &proxy_info);
+    TCP_Connections *tc_2 = new_tcp_connections(logger, mem, rng, ns, mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(pk_equal(tcp_connections_public_key(tc_2), self_public_key), "Wrong public key");
 
     IP_Port ip_port_tcp_s;
@@ -841,17 +866,17 @@ static void test_tcp_connection2(void)
     ck_assert_msg(add_tcp_relay_global(tc_2, &ip_port_tcp_s, tcp_server_public_key(tcp_s)) == 0,
                   "Could not add global relay");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
@@ -861,14 +886,14 @@ static void test_tcp_connection2(void)
     set_oob_packet_tcp_connection_callback(tc_2, &tcp_oobdata_callback, tc_2);
     set_packet_tcp_connection_callback(tc_1, &tcp_data_callback, (void *) 120397);
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
 
     ck_assert_msg(tcp_oobdata_callback_called, "could not recv packet.");
 
-    do_TCP_server_delay(tcp_s, mono_time, 50);
+    do_tcp_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(logger, tc_1, nullptr);
     do_tcp_connections(logger, tc_2, nullptr);
@@ -876,15 +901,15 @@ static void test_tcp_connection2(void)
     ck_assert_msg(tcp_data_callback_called, "could not recv packet.");
     ck_assert_msg(kill_tcp_connection_to(tc_1, 0) == 0, "could not kill connection to\n");
 
-    kill_TCP_server(tcp_s);
+    kill_tcp_server(tcp_s);
     kill_tcp_connections(tc_1);
     kill_tcp_connections(tc_2);
 
     logger_kill(logger);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
 }
 
-static void TCP_suite(void)
+static void tcp_suite(void)
 {
     test_basic();
     test_some();
@@ -897,6 +922,6 @@ static void TCP_suite(void)
 int main(void)
 {
     setvbuf(stdout, nullptr, _IONBF, 0);
-    TCP_suite();
+    tcp_suite();
     return 0;
 }

external/toxcore/c-toxcore/auto_tests/announce_test.c

@@ -54,14 +54,17 @@ static void test_store_data(void)
     ck_assert(rng != nullptr);
     const Network *ns = system_network();
     ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+
     Logger *log = logger_new();
     ck_assert(log != nullptr);
     logger_callback_log(log, print_debug_logger, nullptr, nullptr);
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
-    Networking_Core *net = new_networking_no_udp(log, ns);
-    DHT *dht = new_dht(log, rng, ns, mono_time, net, true, true);
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
+    Networking_Core *net = new_networking_no_udp(log, mem, ns);
+    DHT *dht = new_dht(log, mem, rng, ns, mono_time, net, true, true);
     Forwarding *forwarding = new_forwarding(log, rng, mono_time, dht);
-    Announcements *announce = new_announcements(log, rng, mono_time, forwarding);
+    Announcements *announce = new_announcements(log, mem, rng, mono_time, forwarding);
     ck_assert(announce != nullptr);
 
     /* Just to prevent CI from complaining that set_synch_offset is unused: */
@@ -103,7 +106,7 @@ static void test_store_data(void)
     kill_forwarding(forwarding);
     kill_dht(dht);
     kill_networking(net);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
     logger_kill(log);
 }
 

external/toxcore/c-toxcore/auto_tests/auto_test_support.c

@@ -13,7 +13,7 @@
 #define ABORT_ON_LOG_ERROR true
 #endif
 
-Run_Auto_Options default_run_auto_options()
+Run_Auto_Options default_run_auto_options(void)
 {
     return (Run_Auto_Options) {
         .graph = GRAPH_COMPLETE,
@@ -27,7 +27,7 @@ static const struct BootstrapNodes {
     const char   *ip;
     uint16_t      port;
     const uint8_t key[32];
-} BootstrapNodes[] = {
+} bootstrap_nodes[] = {
 #ifndef USE_TEST_NETWORK
     {
         "tox.abilinski.com", 33445,
@@ -80,10 +80,10 @@ void bootstrap_tox_live_network(Tox *tox, bool enable_tcp)
 {
     ck_assert(tox != nullptr);
 
-    for (size_t j = 0; BootstrapNodes[j].ip != nullptr; ++j) {
-        const char *ip = BootstrapNodes[j].ip;
-        uint16_t port = BootstrapNodes[j].port;
-        const uint8_t *key = BootstrapNodes[j].key;
+    for (size_t j = 0; bootstrap_nodes[j].ip != nullptr; ++j) {
+        const char *ip = bootstrap_nodes[j].ip;
+        uint16_t port = bootstrap_nodes[j].port;
+        const uint8_t *key = bootstrap_nodes[j].key;
 
         Tox_Err_Bootstrap err;
         tox_bootstrap(tox, ip, port, key, &err);

external/toxcore/c-toxcore/auto_tests/conference_av_test.c

@@ -217,7 +217,7 @@ static bool test_audio(AutoTox *autotoxes, const bool *disabled, bool quiet)
         printf("testing sending and receiving audio\n");
     }
 
-    const int16_t PCM[GROUP_AV_TEST_SAMPLES] = {0};
+    const int16_t pcm[GROUP_AV_TEST_SAMPLES] = {0};
 
     reset_received_audio(autotoxes);
 
@@ -227,7 +227,7 @@ static bool test_audio(AutoTox *autotoxes, const bool *disabled, bool quiet)
                 continue;
             }
 
-            if (toxav_group_send_audio(autotoxes[i].tox, 0, PCM, GROUP_AV_TEST_SAMPLES, 1, 48000) != 0) {
+            if (toxav_group_send_audio(autotoxes[i].tox, 0, pcm, GROUP_AV_TEST_SAMPLES, 1, 48000) != 0) {
                 if (!quiet) {
                     ck_abort_msg("#%u failed to send audio", autotoxes[i].index);
                 }
@@ -255,8 +255,12 @@ static void test_eventual_audio(AutoTox *autotoxes, const bool *disabled, uint64
     uint64_t start = autotoxes[0].clock;
 
     while (autotoxes[0].clock < start + timeout) {
-        if (test_audio(autotoxes, disabled, true)
-                && test_audio(autotoxes, disabled, true)) {
+        if (!test_audio(autotoxes, disabled, true)) {
+            continue;
+        }
+
+        // It needs to succeed twice in a row for the test to pass.
+        if (test_audio(autotoxes, disabled, true)) {
             printf("audio test successful after %d seconds\n", (int)((autotoxes[0].clock - start) / 1000));
             return;
         }
@@ -268,12 +272,12 @@ static void test_eventual_audio(AutoTox *autotoxes, const bool *disabled, uint64
 
 static void do_audio(AutoTox *autotoxes, uint32_t iterations)
 {
-    const int16_t PCM[GROUP_AV_TEST_SAMPLES] = {0};
+    const int16_t pcm[GROUP_AV_TEST_SAMPLES] = {0};
     printf("running audio for %u iterations\n", iterations);
 
     for (uint32_t f = 0; f < iterations; ++f) {
         for (uint32_t i = 0; i < NUM_AV_GROUP_TOX; ++i) {
-            ck_assert_msg(toxav_group_send_audio(autotoxes[i].tox, 0, PCM, GROUP_AV_TEST_SAMPLES, 1, 48000) == 0,
+            ck_assert_msg(toxav_group_send_audio(autotoxes[i].tox, 0, pcm, GROUP_AV_TEST_SAMPLES, 1, 48000) == 0,
                           "#%u failed to send audio", autotoxes[i].index);
             iterate_all_wait(autotoxes, NUM_AV_GROUP_TOX, ITERATION_INTERVAL);
         }

external/toxcore/c-toxcore/auto_tests/crypto_test.c

@@ -9,9 +9,7 @@
 
 static void rand_bytes(const Random *rng, uint8_t *b, size_t blen)
 {
-    size_t i;
-
-    for (i = 0; i < blen; i++) {
+    for (size_t i = 0; i < blen; i++) {
         b[i] = random_u08(rng);
     }
 }
@@ -84,19 +82,18 @@ static void test_known(void)
 {
     uint8_t c[147];
     uint8_t m[131];
-    uint16_t clen, mlen;
 
     ck_assert_msg(sizeof(c) == sizeof(m) + CRYPTO_MAC_SIZE * sizeof(uint8_t),
                   "cyphertext should be CRYPTO_MAC_SIZE bytes longer than plaintext");
     ck_assert_msg(sizeof(test_c) == sizeof(c), "sanity check failed");
     ck_assert_msg(sizeof(test_m) == sizeof(m), "sanity check failed");
 
-    clen = encrypt_data(bobpk, alicesk, test_nonce, test_m, sizeof(test_m) / sizeof(uint8_t), c);
+    const uint16_t clen = encrypt_data(bobpk, alicesk, test_nonce, test_m, sizeof(test_m) / sizeof(uint8_t), c);
 
     ck_assert_msg(memcmp(test_c, c, sizeof(c)) == 0, "cyphertext doesn't match test vector");
     ck_assert_msg(clen == sizeof(c) / sizeof(uint8_t), "wrong ciphertext length");
 
-    mlen = decrypt_data(bobpk, alicesk, test_nonce, test_c, sizeof(test_c) / sizeof(uint8_t), m);
+    const uint16_t mlen = decrypt_data(bobpk, alicesk, test_nonce, test_c, sizeof(test_c) / sizeof(uint8_t), m);
 
     ck_assert_msg(memcmp(test_m, m, sizeof(m)) == 0, "decrypted text doesn't match test vector");
     ck_assert_msg(mlen == sizeof(m) / sizeof(uint8_t), "wrong plaintext length");
@@ -107,7 +104,6 @@ static void test_fast_known(void)
     uint8_t k[CRYPTO_SHARED_KEY_SIZE];
     uint8_t c[147];
     uint8_t m[131];
-    uint16_t clen, mlen;
 
     encrypt_precompute(bobpk, alicesk, k);
 
@@ -116,12 +112,12 @@ static void test_fast_known(void)
     ck_assert_msg(sizeof(test_c) == sizeof(c), "sanity check failed");
     ck_assert_msg(sizeof(test_m) == sizeof(m), "sanity check failed");
 
-    clen = encrypt_data_symmetric(k, test_nonce, test_m, sizeof(test_m) / sizeof(uint8_t), c);
+    const uint16_t clen = encrypt_data_symmetric(k, test_nonce, test_m, sizeof(test_m) / sizeof(uint8_t), c);
 
     ck_assert_msg(memcmp(test_c, c, sizeof(c)) == 0, "cyphertext doesn't match test vector");
     ck_assert_msg(clen == sizeof(c) / sizeof(uint8_t), "wrong ciphertext length");
 
-    mlen = decrypt_data_symmetric(k, test_nonce, test_c, sizeof(test_c) / sizeof(uint8_t), m);
+    const uint16_t mlen = decrypt_data_symmetric(k, test_nonce, test_c, sizeof(test_c) / sizeof(uint8_t), m);
 
     ck_assert_msg(memcmp(test_m, m, sizeof(m)) == 0, "decrypted text doesn't match test vector");
     ck_assert_msg(mlen == sizeof(m) / sizeof(uint8_t), "wrong plaintext length");
@@ -273,12 +269,36 @@ static void test_large_data_symmetric(void)
     free(m1);
 }
 
+static void test_very_large_data(void)
+{
+    const Random *rng = system_random();
+    ck_assert(rng != nullptr);
+
+    uint8_t nonce[CRYPTO_NONCE_SIZE] = {0};
+    uint8_t pk[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t sk[CRYPTO_SECRET_KEY_SIZE];
+    crypto_new_keypair(rng, pk, sk);
+
+    // 100 MiB of data (all zeroes, doesn't matter what's inside).
+    const uint32_t plain_size = 100 * 1024 * 1024;
+    uint8_t *plain = (uint8_t *)malloc(plain_size);
+    uint8_t *encrypted = (uint8_t *)malloc(plain_size + CRYPTO_MAC_SIZE);
+
+    ck_assert(plain != nullptr);
+    ck_assert(encrypted != nullptr);
+
+    encrypt_data(pk, sk, nonce, plain, plain_size, encrypted);
+
+    free(encrypted);
+    free(plain);
+}
+
 static void increment_nonce_number_cmp(uint8_t *nonce, uint32_t num)
 {
-    uint32_t num1, num2;
+    uint32_t num1 = 0;
     memcpy(&num1, nonce + (CRYPTO_NONCE_SIZE - sizeof(num1)), sizeof(num1));
     num1 = net_ntohl(num1);
-    num2 = num + num1;
+    uint32_t num2 = num + num1;
 
     if (num2 < num1) {
         for (uint16_t i = CRYPTO_NONCE_SIZE - sizeof(num1); i != 0; --i) {
@@ -299,11 +319,9 @@ static void test_increment_nonce(void)
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
 
-    uint32_t i;
-
     uint8_t n[CRYPTO_NONCE_SIZE];
 
-    for (i = 0; i < CRYPTO_NONCE_SIZE; ++i) {
+    for (uint32_t i = 0; i < CRYPTO_NONCE_SIZE; ++i) {
         n[i] = random_u08(rng);
     }
 
@@ -311,13 +329,13 @@ static void test_increment_nonce(void)
 
     memcpy(n1, n, CRYPTO_NONCE_SIZE);
 
-    for (i = 0; i < (1 << 18); ++i) {
+    for (uint32_t i = 0; i < (1 << 18); ++i) {
         increment_nonce_number_cmp(n, 1);
         increment_nonce(n1);
         ck_assert_msg(memcmp(n, n1, CRYPTO_NONCE_SIZE) == 0, "Bad increment_nonce function");
     }
 
-    for (i = 0; i < (1 << 18); ++i) {
+    for (uint32_t i = 0; i < (1 << 18); ++i) {
         const uint32_t r = random_u32(rng);
         increment_nonce_number_cmp(n, r);
         increment_nonce_number(n1, r);
@@ -331,9 +349,8 @@ static void test_memzero(void)
     memcpy(src, test_c, sizeof(test_c));
 
     crypto_memzero(src, sizeof(src));
-    size_t i;
 
-    for (i = 0; i < sizeof(src); i++) {
+    for (size_t i = 0; i < sizeof(src); i++) {
         ck_assert_msg(src[i] == 0, "Memory is not zeroed");
     }
 }
@@ -347,6 +364,7 @@ int main(void)
     test_endtoend(); /* waiting up to 15 seconds */
     test_large_data();
     test_large_data_symmetric();
+    test_very_large_data();
     test_increment_nonce();
     test_memzero();
 

external/toxcore/c-toxcore/auto_tests/dht_getnodes_api_test.c

@@ -122,6 +122,12 @@ static void test_dht_getnodes(AutoTox *autotoxes)
 
         tox_self_get_dht_id(autotoxes[i].tox, public_key_list[i]);
         tox_callback_dht_get_nodes_response(autotoxes[i].tox, getnodes_response_cb);
+
+        printf("Peer %zu dht closenode count total/announce-capable: %d/%d\n",
+            i,
+            tox_dht_get_num_closelist(autotoxes[i].tox),
+            tox_dht_get_num_closelist_announce_capable(autotoxes[i].tox)
+        );
     }
 
     while (!all_nodes_crawled(autotoxes, NUM_TOXES, public_key_list)) {

external/toxcore/c-toxcore/auto_tests/file_transfer_test.c

@@ -172,12 +172,12 @@ static void file_transfer_test(void)
     uint32_t test = tox_friend_add(tox3, address, (const uint8_t *)"Gentoo", 7, nullptr);
     ck_assert_msg(test == 0, "Failed to add friend error code: %u", test);
 
-    uint8_t dhtKey[TOX_PUBLIC_KEY_SIZE];
-    tox_self_get_dht_id(tox1, dhtKey);
-    uint16_t dhtPort = tox_self_get_udp_port(tox1, nullptr);
+    uint8_t dht_key[TOX_PUBLIC_KEY_SIZE];
+    tox_self_get_dht_id(tox1, dht_key);
+    uint16_t dht_port = tox_self_get_udp_port(tox1, nullptr);
 
-    tox_bootstrap(tox2, TOX_LOCALHOST, dhtPort, dhtKey, nullptr);
-    tox_bootstrap(tox3, TOX_LOCALHOST, dhtPort, dhtKey, nullptr);
+    tox_bootstrap(tox2, TOX_LOCALHOST, dht_port, dht_key, nullptr);
+    tox_bootstrap(tox3, TOX_LOCALHOST, dht_port, dht_key, nullptr);
 
     printf("Waiting for toxes to come online\n");
 

external/toxcore/c-toxcore/auto_tests/forwarding_test.c

@@ -102,56 +102,58 @@ typedef struct Forwarding_Subtox {
     Announcements *announce;
 } Forwarding_Subtox;
 
-static Forwarding_Subtox *new_forwarding_subtox(bool no_udp, uint32_t *index, uint16_t port)
+static Forwarding_Subtox *new_forwarding_subtox(const Memory *mem, bool no_udp, uint32_t *index, uint16_t port)
 {
+    const Random *rng = system_random();
+    ck_assert(rng != nullptr);
+    const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+
     Forwarding_Subtox *subtox = (Forwarding_Subtox *)calloc(1, sizeof(Forwarding_Subtox));
     ck_assert(subtox != nullptr);
 
     subtox->log = logger_new();
     ck_assert(subtox->log != nullptr);
     logger_callback_log(subtox->log, print_debug_logger, nullptr, index);
-    subtox->mono_time = mono_time_new(nullptr, nullptr);
-
-    const Random *rng= system_random();
-    ck_assert(rng != nullptr);
-    const Network *ns = system_network();
-    ck_assert(ns != nullptr);
+    subtox->mono_time = mono_time_new(mem, nullptr, nullptr);
 
     if (no_udp) {
-        subtox->net = new_networking_no_udp(subtox->log, ns);
+        subtox->net = new_networking_no_udp(subtox->log, mem, ns);
     } else {
         const IP ip = get_loopback();
-        subtox->net = new_networking_ex(subtox->log, ns, &ip, port, port, nullptr);
+        subtox->net = new_networking_ex(subtox->log, mem, ns, &ip, port, port, nullptr);
     }
 
-    subtox->dht = new_dht(subtox->log, rng, ns, subtox->mono_time, subtox->net, true, true);
+    subtox->dht = new_dht(subtox->log, mem, rng, ns, subtox->mono_time, subtox->net, true, true);
 
     const TCP_Proxy_Info inf = {{{{0}}}};
-    subtox->c = new_net_crypto(subtox->log, rng, ns, subtox->mono_time, subtox->dht, &inf);
+    subtox->c = new_net_crypto(subtox->log, mem, rng, ns, subtox->mono_time, subtox->dht, &inf);
 
     subtox->forwarding = new_forwarding(subtox->log, rng, subtox->mono_time, subtox->dht);
     ck_assert(subtox->forwarding != nullptr);
 
-    subtox->announce = new_announcements(subtox->log, rng, subtox->mono_time, subtox->forwarding);
+    subtox->announce = new_announcements(subtox->log, mem, rng, subtox->mono_time, subtox->forwarding);
     ck_assert(subtox->announce != nullptr);
 
     return subtox;
 }
 
-static void kill_forwarding_subtox(Forwarding_Subtox *subtox)
+static void kill_forwarding_subtox(const Memory *mem, Forwarding_Subtox *subtox)
 {
     kill_announcements(subtox->announce);
     kill_forwarding(subtox->forwarding);
     kill_net_crypto(subtox->c);
     kill_dht(subtox->dht);
     kill_networking(subtox->net);
-    mono_time_free(subtox->mono_time);
+    mono_time_free(mem, subtox->mono_time);
     logger_kill(subtox->log);
     free(subtox);
 }
 
 static void test_forwarding(void)
 {
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
     const Network *ns = system_network();
@@ -165,7 +167,7 @@ static void test_forwarding(void)
 
     for (uint32_t i = 0; i < NUM_FORWARDER; ++i) {
         index[i] = i + 1;
-        subtoxes[i] = new_forwarding_subtox(i < NUM_FORWARDER_TCP, &index[i], FORWARDING_BASE_PORT + i);
+        subtoxes[i] = new_forwarding_subtox(mem, i < NUM_FORWARDER_TCP, &index[i], FORWARDING_BASE_PORT + i);
 
         test_data[i].net = subtoxes[i]->net;
         test_data[i].send_back = 0;
@@ -317,7 +319,7 @@ static void test_forwarding(void)
 
 
     for (uint32_t i = 0; i < NUM_FORWARDER; ++i) {
-        kill_forwarding_subtox(subtoxes[i]);
+        kill_forwarding_subtox(mem, subtoxes[i]);
     }
 
     tox_kill(relay);

external/toxcore/c-toxcore/auto_tests/group_message_test.c

@@ -44,6 +44,10 @@ typedef struct State {
 #define TEST_CUSTOM_PACKET "Why'd ya spill yer beans?"
 #define TEST_CUSTOM_PACKET_LEN (sizeof(TEST_CUSTOM_PACKET) - 1)
 
+#define TEST_CUSTOM_PACKET_LARGE "Where is it I've read that someone condemned to death says or thinks, an hour before his death, that if he had to live on some high rock, on such a narrow ledge that he'd only room to stand, and the ocean, everlasting darkness, everlasting solitude, everlasting tempest around him, if he had to remain standing on a square yard of space all his life, a thousand years, eternity, it were better to live so than to die at once. Only to live, to live and live! Life, whatever it may be! ...............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................0123456789"
+#define TEST_CUSTOM_PACKET_LARGE_LEN (sizeof(TEST_CUSTOM_PACKET_LARGE) - 1)
+static_assert(TEST_CUSTOM_PACKET_LARGE_LEN == TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH, "Should be max");
+
 #define TEST_CUSTOM_PRIVATE_PACKET "This is a custom private packet. Enjoy."
 #define TEST_CUSTOM_PRIVATE_PACKET_LEN (sizeof(TEST_CUSTOM_PRIVATE_PACKET) - 1)
 
@@ -187,6 +191,21 @@ static void group_custom_packet_handler(Tox *tox, uint32_t groupnumber, uint32_t
     ++state->custom_packets_received;
 }
 
+static void group_custom_packet_large_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *data,
+                                        size_t length, void *user_data)
+{
+    ck_assert_msg(length == TEST_CUSTOM_PACKET_LARGE_LEN, "Failed to receive large custom packet. Invalid length: %zu\n", length);
+
+    ck_assert(memcmp(data, TEST_CUSTOM_PACKET_LARGE, length) == 0);
+
+    AutoTox *autotox = (AutoTox *)user_data;
+    ck_assert(autotox != nullptr);
+
+    State *state = (State *)autotox->state;
+
+    ++state->custom_packets_received;
+}
+
 static void group_message_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_MESSAGE_TYPE type,
                                   const uint8_t *message, size_t length, uint32_t pseudo_msg_id, void *user_data)
 {
@@ -450,6 +469,19 @@ static void group_message_test(AutoTox *autotoxes)
         iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL);
     }
 
+    // tox0 sends a large max sized lossy custom packet
+
+    // overwrite callback for larger packet
+    tox_callback_group_custom_packet(tox0, group_custom_packet_large_handler);
+
+    tox_group_send_custom_packet(tox1, group_number, false, (const uint8_t *)TEST_CUSTOM_PACKET_LARGE, TEST_CUSTOM_PACKET_LARGE_LEN,
+                                 &c_err);
+    ck_assert_msg(c_err == TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK, "%d", c_err);
+
+    while (state0->custom_packets_received < 3) {
+        iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL);
+    }
+
     uint8_t m[TOX_GROUP_MAX_MESSAGE_LENGTH] = {0};
 
     fprintf(stderr, "Doing lossless packet test...\n");
@@ -538,6 +570,8 @@ int main(void)
 #undef TEST_PRIVATE_MESSAGE_LEN
 #undef TEST_CUSTOM_PACKET
 #undef TEST_CUSTOM_PACKET_LEN
+#undef TEST_CUSTOM_PACKET_LARGE
+#undef TEST_CUSTOM_PACKET_LARGE_LEN
 #undef TEST_CUSTOM_PRIVATE_PACKET
 #undef TEST_CUSTOM_PRIVATE_PACKET_LEN
 #undef IGNORE_MESSAGE

external/toxcore/c-toxcore/auto_tests/onion_test.c

@@ -215,29 +215,32 @@ static void send_onion_packet(const Networking_Core *net, const Random *rng, con
 /** Initialize networking.
  * Added for reverse compatibility with old new_networking calls.
  */
-static Networking_Core *new_networking(const Logger *log, const Network *ns, const IP *ip, uint16_t port)
+static Networking_Core *new_networking(const Logger *log, const Memory *mem, const Network *ns, const IP *ip, uint16_t port)
 {
-    return new_networking_ex(log, ns, ip, port, port + (TOX_PORTRANGE_TO - TOX_PORTRANGE_FROM), nullptr);
+    return new_networking_ex(log, mem, ns, ip, port, port + (TOX_PORTRANGE_TO - TOX_PORTRANGE_FROM), nullptr);
 }
 
 static void test_basic(void)
 {
     uint32_t index[] = { 1, 2, 3 };
     const Network *ns = system_network();
+    ck_assert(ns != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
+    const Random *rng = system_random();
+    ck_assert(rng != nullptr);
 
     Logger *log1 = logger_new();
     logger_callback_log(log1, print_debug_logger, nullptr, &index[0]);
     Logger *log2 = logger_new();
     logger_callback_log(log2, print_debug_logger, nullptr, &index[1]);
 
-    const Random *rng = system_random();
-    ck_assert(rng != nullptr);
-    Mono_Time *mono_time1 = mono_time_new(nullptr, nullptr);
-    Mono_Time *mono_time2 = mono_time_new(nullptr, nullptr);
+    Mono_Time *mono_time1 = mono_time_new(mem, nullptr, nullptr);
+    Mono_Time *mono_time2 = mono_time_new(mem, nullptr, nullptr);
 
     IP ip = get_loopback();
-    Onion *onion1 = new_onion(log1, mono_time1, rng, new_dht(log1, rng, ns, mono_time1, new_networking(log1, ns, &ip, 36567), true, false));
-    Onion *onion2 = new_onion(log2, mono_time2, rng, new_dht(log2, rng, ns, mono_time2, new_networking(log2, ns, &ip, 36568), true, false));
+    Onion *onion1 = new_onion(log1, mem, mono_time1, rng, new_dht(log1, mem, rng, ns, mono_time1, new_networking(log1, mem, ns, &ip, 36567), true, false));
+    Onion *onion2 = new_onion(log2, mem, mono_time2, rng, new_dht(log2, mem, rng, ns, mono_time2, new_networking(log2, mem, ns, &ip, 36568), true, false));
     ck_assert_msg((onion1 != nullptr) && (onion2 != nullptr), "Onion failed initializing.");
     networking_registerhandler(onion2->net, NET_PACKET_ANNOUNCE_REQUEST, &handle_test_1, onion2);
 
@@ -280,8 +283,8 @@ static void test_basic(void)
         do_onion(mono_time2, onion2);
     } while (handled_test_2 == 0);
 
-    Onion_Announce *onion1_a = new_onion_announce(log1, rng, mono_time1, onion1->dht);
-    Onion_Announce *onion2_a = new_onion_announce(log2, rng, mono_time2, onion2->dht);
+    Onion_Announce *onion1_a = new_onion_announce(log1, mem, rng, mono_time1, onion1->dht);
+    Onion_Announce *onion2_a = new_onion_announce(log2, mem, rng, mono_time2, onion2->dht);
     networking_registerhandler(onion1->net, NET_PACKET_ANNOUNCE_RESPONSE, &handle_test_3, onion1);
     networking_registerhandler(onion1->net, NET_PACKET_ANNOUNCE_RESPONSE_OLD, &handle_test_3_old, onion1);
     ck_assert_msg((onion1_a != nullptr) && (onion2_a != nullptr), "Onion_Announce failed initializing.");
@@ -331,9 +334,9 @@ static void test_basic(void)
     Logger *log3 = logger_new();
     logger_callback_log(log3, print_debug_logger, nullptr, &index[2]);
 
-    Mono_Time *mono_time3 = mono_time_new(nullptr, nullptr);
+    Mono_Time *mono_time3 = mono_time_new(mem, nullptr, nullptr);
 
-    Onion *onion3 = new_onion(log3, mono_time3, rng, new_dht(log3, rng, ns, mono_time3, new_networking(log3, ns, &ip, 36569), true, false));
+    Onion *onion3 = new_onion(log3, mem, mono_time3, rng, new_dht(log3, mem, rng, ns, mono_time3, new_networking(log3, mem, ns, &ip, 36569), true, false));
     ck_assert_msg((onion3 != nullptr), "Onion failed initializing.");
 
     random_nonce(rng, nonce);
@@ -363,7 +366,7 @@ static void test_basic(void)
         kill_onion(onion);
         kill_dht(dht);
         kill_networking(net);
-        mono_time_free(mono_time3);
+        mono_time_free(mem, mono_time3);
         logger_kill(log3);
     }
 
@@ -375,7 +378,7 @@ static void test_basic(void)
         kill_onion(onion);
         kill_dht(dht);
         kill_networking(net);
-        mono_time_free(mono_time2);
+        mono_time_free(mem, mono_time2);
         logger_kill(log2);
     }
 
@@ -387,7 +390,7 @@ static void test_basic(void)
         kill_onion(onion);
         kill_dht(dht);
         kill_networking(net);
-        mono_time_free(mono_time1);
+        mono_time_free(mem, mono_time1);
         logger_kill(log1);
     }
 }
@@ -400,7 +403,7 @@ typedef struct {
     Onion_Client *onion_c;
 } Onions;
 
-static Onions *new_onions(const Random *rng, uint16_t port, uint32_t *index)
+static Onions *new_onions(const Memory *mem, const Random *rng, uint16_t port, uint32_t *index)
 {
     IP ip = get_loopback();
     ip.ip.v6.uint8[15] = 1;
@@ -420,7 +423,7 @@ static Onions *new_onions(const Random *rng, uint16_t port, uint32_t *index)
 
     logger_callback_log(on->log, print_debug_logger, nullptr, index);
 
-    on->mono_time = mono_time_new(nullptr, nullptr);
+    on->mono_time = mono_time_new(mem, nullptr, nullptr);
 
     if (!on->mono_time) {
         logger_kill(on->log);
@@ -428,57 +431,57 @@ static Onions *new_onions(const Random *rng, uint16_t port, uint32_t *index)
         return nullptr;
     }
 
-    Networking_Core *net = new_networking(on->log, ns, &ip, port);
+    Networking_Core *net = new_networking(on->log, mem, ns, &ip, port);
 
     if (!net) {
-        mono_time_free(on->mono_time);
+        mono_time_free(mem, on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
-    DHT *dht = new_dht(on->log, rng, ns, on->mono_time, net, true, false);
+    DHT *dht = new_dht(on->log, mem, rng, ns, on->mono_time, net, true, false);
 
     if (!dht) {
         kill_networking(net);
-        mono_time_free(on->mono_time);
+        mono_time_free(mem, on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
-    on->onion = new_onion(on->log, on->mono_time, rng, dht);
+    on->onion = new_onion(on->log, mem, on->mono_time, rng, dht);
 
     if (!on->onion) {
         kill_dht(dht);
         kill_networking(net);
-        mono_time_free(on->mono_time);
+        mono_time_free(mem, on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
-    on->onion_a = new_onion_announce(on->log, rng, on->mono_time, dht);
+    on->onion_a = new_onion_announce(on->log, mem, rng, on->mono_time, dht);
 
     if (!on->onion_a) {
         kill_onion(on->onion);
         kill_dht(dht);
         kill_networking(net);
-        mono_time_free(on->mono_time);
+        mono_time_free(mem, on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
     TCP_Proxy_Info inf = {{{{0}}}};
-    on->onion_c = new_onion_client(on->log, rng, on->mono_time, new_net_crypto(on->log, rng, ns, on->mono_time, dht, &inf));
+    on->onion_c = new_onion_client(on->log, mem, rng, on->mono_time, new_net_crypto(on->log, mem, rng, ns, on->mono_time, dht, &inf));
 
     if (!on->onion_c) {
         kill_onion_announce(on->onion_a);
         kill_onion(on->onion);
         kill_dht(dht);
         kill_networking(net);
-        mono_time_free(on->mono_time);
+        mono_time_free(mem, on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
@@ -496,7 +499,7 @@ static void do_onions(Onions *on)
     do_onion_client(on->onion_c);
 }
 
-static void kill_onions(Onions *on)
+static void kill_onions(const Memory *mem, Onions *on)
 {
     Networking_Core *net = dht_get_net(on->onion->dht);
     DHT *dht = on->onion->dht;
@@ -507,7 +510,7 @@ static void kill_onions(Onions *on)
     kill_net_crypto(c);
     kill_dht(dht);
     kill_networking(net);
-    mono_time_free(on->mono_time);
+    mono_time_free(mem, on->mono_time);
     logger_kill(on->log);
     free(on);
 }
@@ -571,21 +574,22 @@ static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_pub
 
 static void test_announce(void)
 {
-    uint32_t i, j;
     uint32_t index[NUM_ONIONS];
     Onions *onions[NUM_ONIONS];
     const Random *rng = system_random();
     ck_assert(rng != nullptr);
+    const Memory *mem = system_memory();
+    ck_assert(mem != nullptr);
 
-    for (i = 0; i < NUM_ONIONS; ++i) {
+    for (uint32_t i = 0; i < NUM_ONIONS; ++i) {
         index[i] = i + 1;
-        onions[i] = new_onions(rng, i + 36655, &index[i]);
+        onions[i] = new_onions(mem, rng, i + 36655, &index[i]);
         ck_assert_msg(onions[i] != nullptr, "Failed to create onions. %u", i);
     }
 
     IP ip = get_loopback();
 
-    for (i = 3; i < NUM_ONIONS; ++i) {
+    for (uint32_t i = 3; i < NUM_ONIONS; ++i) {
         IP_Port ip_port = {ip, net_port(onions[i - 1]->onion->net)};
         dht_bootstrap(onions[i]->onion->dht, &ip_port, dht_get_self_public_key(onions[i - 1]->onion->dht));
         IP_Port ip_port1 = {ip, net_port(onions[i - 2]->onion->net)};
@@ -599,7 +603,7 @@ static void test_announce(void)
     do {
         connected = 0;
 
-        for (i = 0; i < NUM_ONIONS; ++i) {
+        for (uint32_t i = 0; i < NUM_ONIONS; ++i) {
             do_onions(onions[i]);
             connected += dht_isconnected(onions[i]->onion->dht);
         }
@@ -609,8 +613,8 @@ static void test_announce(void)
 
     printf("connected\n");
 
-    for (i = 0; i < 25 * 2; ++i) {
-        for (j = 0; j < NUM_ONIONS; ++j) {
+    for (uint32_t i = 0; i < 25 * 2; ++i) {
+        for (uint32_t j = 0; j < NUM_ONIONS; ++j) {
             do_onions(onions[j]);
         }
 
@@ -632,7 +636,7 @@ static void test_announce(void)
     IP_Port ip_port;
 
     do {
-        for (i = 0; i < NUM_ONIONS; ++i) {
+        for (uint32_t i = 0; i < NUM_ONIONS; ++i) {
             do_onions(onions[i]);
         }
 
@@ -642,7 +646,7 @@ static void test_announce(void)
     printf("Waiting for ips\n");
 
     do {
-        for (i = 0; i < NUM_ONIONS; ++i) {
+        for (uint32_t i = 0; i < NUM_ONIONS; ++i) {
             do_onions(onions[i]);
         }
 
@@ -652,8 +656,8 @@ static void test_announce(void)
     onion_getfriendip(onions[NUM_LAST]->onion_c, frnum, &ip_port);
     ck_assert_msg(ip_port.port == net_port(onions[NUM_FIRST]->onion->net), "Port in returned ip not correct.");
 
-    for (i = 0; i < NUM_ONIONS; ++i) {
-        kill_onions(onions[i]);
+    for (uint32_t i = 0; i < NUM_ONIONS; ++i) {
+        kill_onions(mem, onions[i]);
     }
 }
 

external/toxcore/c-toxcore/auto_tests/tox_dispatch_test.c

@@ -43,7 +43,7 @@ static void dump_events(const char *path, const Tox_Events *events)
     }
 }
 
-static void print_events(Tox_Events *events)
+static void print_events(const Tox_System *sys, Tox_Events *events)
 {
     const uint32_t size = tox_events_bytes_size(events);
 
@@ -52,11 +52,11 @@ static void print_events(Tox_Events *events)
 
     tox_events_get_bytes(events, bytes);
 
-    Tox_Events *events_copy = tox_events_load(bytes, size);
+    Tox_Events *events_copy = tox_events_load(sys, bytes, size);
     ck_assert(events_copy != nullptr);
     free(bytes);
 
-    ck_assert(tox_events_equal(events, events_copy));
+    ck_assert(tox_events_equal(sys, events, events_copy));
 
     tox_events_free(events_copy);
     tox_events_free(events);
@@ -64,9 +64,11 @@ static void print_events(Tox_Events *events)
 
 static bool await_message(Tox **toxes, const Tox_Dispatch *dispatch)
 {
+    const Tox_System *sys = tox_get_system(toxes[0]);
+
     for (uint32_t i = 0; i < 100; ++i) {
         // Ignore events on tox 1.
-        print_events(tox_events_iterate(toxes[0], false, nullptr));
+        print_events(sys, tox_events_iterate(toxes[0], false, nullptr));
         // Check if tox 2 got the message from tox 1.
         Tox_Events *events = tox_events_iterate(toxes[1], false, nullptr);
 
@@ -74,7 +76,7 @@ static bool await_message(Tox **toxes, const Tox_Dispatch *dispatch)
 
         bool success = false;
         tox_dispatch_invoke(dispatch, events, toxes[1], &success);
-        print_events(events);
+        print_events(sys, events);
 
         if (success) {
             return true;
@@ -101,6 +103,8 @@ static void test_tox_events(void)
         ck_assert_msg(toxes[i] != nullptr, "failed to create tox instances %u", i);
     }
 
+    const Tox_System *sys = tox_get_system(toxes[0]);
+
     Tox_Err_Dispatch_New err_new;
     Tox_Dispatch *dispatch = tox_dispatch_new(&err_new);
     ck_assert_msg(dispatch != nullptr, "failed to create event dispatcher");
@@ -123,8 +127,8 @@ static void test_tox_events(void)
     while (tox_self_get_connection_status(toxes[0]) == TOX_CONNECTION_NONE ||
             tox_self_get_connection_status(toxes[1]) == TOX_CONNECTION_NONE) {
         // Ignore connection events for now.
-        print_events(tox_events_iterate(toxes[0], false, nullptr));
-        print_events(tox_events_iterate(toxes[1], false, nullptr));
+        print_events(sys, tox_events_iterate(toxes[0], false, nullptr));
+        print_events(sys, tox_events_iterate(toxes[1], false, nullptr));
 
         c_sleep(tox_iteration_interval(toxes[0]));
     }
@@ -134,8 +138,8 @@ static void test_tox_events(void)
     while (tox_friend_get_connection_status(toxes[0], 0, nullptr) == TOX_CONNECTION_NONE ||
             tox_friend_get_connection_status(toxes[1], 0, nullptr) == TOX_CONNECTION_NONE) {
         // Ignore connection events for now.
-        print_events(tox_events_iterate(toxes[0], false, nullptr));
-        print_events(tox_events_iterate(toxes[1], false, nullptr));
+        print_events(sys, tox_events_iterate(toxes[0], false, nullptr));
+        print_events(sys, tox_events_iterate(toxes[1], false, nullptr));
 
         c_sleep(tox_iteration_interval(toxes[0]));
     }

external/toxcore/c-toxcore/auto_tests/tox_many_tcp_test.c

@@ -46,10 +46,9 @@ static void test_many_clients_tcp(void)
     long long unsigned int cur_time = time(nullptr);
     Tox *toxes[NUM_TOXES_TCP];
     uint32_t index[NUM_TOXES_TCP];
-    uint32_t i, j;
     uint32_t to_comp = 974536;
 
-    for (i = 0; i < NUM_TOXES_TCP; ++i) {
+    for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
         struct Tox_Options *opts = tox_options_new(nullptr);
 
         if (i == 0) {
@@ -72,7 +71,7 @@ static void test_many_clients_tcp(void)
         tox_callback_friend_request(toxes[i], accept_friend_request);
         uint8_t dpk[TOX_PUBLIC_KEY_SIZE];
         tox_self_get_dht_id(toxes[0], dpk);
-        Tox_Err_Bootstrap error = TOX_ERR_BOOTSTRAP_OK;
+        Tox_Err_Bootstrap error;
         ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, tcp_relay_port, dpk, &error), "add relay error, %u, %d", i,
                       error);
         uint16_t first_port = tox_self_get_udp_port(toxes[0], nullptr);
@@ -88,12 +87,12 @@ static void test_many_clients_tcp(void)
 
     uint8_t address[TOX_ADDRESS_SIZE];
 
-    for (i = 0; i < NUM_FRIENDS; ++i) {
+    for (uint32_t i = 0; i < NUM_FRIENDS; ++i) {
 loop_top:
         pairs[i].tox1 = random_u32(rng) % NUM_TOXES_TCP;
         pairs[i].tox2 = (pairs[i].tox1 + random_u32(rng) % (NUM_TOXES_TCP - 1) + 1) % NUM_TOXES_TCP;
 
-        for (j = 0; j < i; ++j) {
+        for (uint32_t j = 0; j < i; ++j) {
             if (pairs[j].tox2 == pairs[i].tox1 && pairs[j].tox1 == pairs[i].tox2) {
                 goto loop_top;
             }
@@ -114,8 +113,8 @@ loop_top:
     while (true) {
         uint16_t counter = 0;
 
-        for (i = 0; i < NUM_TOXES_TCP; ++i) {
-            for (j = 0; j < tox_self_get_friend_list_size(toxes[i]); ++j) {
+        for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
+            for (uint32_t j = 0; j < tox_self_get_friend_list_size(toxes[i]); ++j) {
                 if (tox_friend_get_connection_status(toxes[i], j, nullptr) == TOX_CONNECTION_TCP) {
                     ++counter;
                 }
@@ -126,14 +125,14 @@ loop_top:
             break;
         }
 
-        for (i = 0; i < NUM_TOXES_TCP; ++i) {
+        for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
             tox_iterate(toxes[i], &to_comp);
         }
 
         c_sleep(50);
     }
 
-    for (i = 0; i < NUM_TOXES_TCP; ++i) {
+    for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
         tox_kill(toxes[i]);
     }
 
@@ -149,10 +148,9 @@ static void test_many_clients_tcp_b(void)
     long long unsigned int cur_time = time(nullptr);
     Tox *toxes[NUM_TOXES_TCP];
     uint32_t index[NUM_TOXES_TCP];
-    uint32_t i, j;
     uint32_t to_comp = 974536;
 
-    for (i = 0; i < NUM_TOXES_TCP; ++i) {
+    for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
         struct Tox_Options *opts = tox_options_new(nullptr);
 
         if (i < NUM_TCP_RELAYS) {
@@ -183,12 +181,12 @@ static void test_many_clients_tcp_b(void)
 
     uint8_t address[TOX_ADDRESS_SIZE];
 
-    for (i = 0; i < NUM_FRIENDS; ++i) {
+    for (uint32_t i = 0; i < NUM_FRIENDS; ++i) {
 loop_top:
         pairs[i].tox1 = random_u32(rng) % NUM_TOXES_TCP;
         pairs[i].tox2 = (pairs[i].tox1 + random_u32(rng) % (NUM_TOXES_TCP - 1) + 1) % NUM_TOXES_TCP;
 
-        for (j = 0; j < i; ++j) {
+        for (uint32_t j = 0; j < i; ++j) {
             if (pairs[j].tox2 == pairs[i].tox1 && pairs[j].tox1 == pairs[i].tox2) {
                 goto loop_top;
             }
@@ -211,8 +209,8 @@ loop_top:
     while (true) {
         uint16_t counter = 0;
 
-        for (i = 0; i < NUM_TOXES_TCP; ++i) {
-            for (j = 0; j < tox_self_get_friend_list_size(toxes[i]); ++j) {
+        for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
+            for (uint32_t j = 0; j < tox_self_get_friend_list_size(toxes[i]); ++j) {
                 if (tox_friend_get_connection_status(toxes[i], j, nullptr) == TOX_CONNECTION_TCP) {
                     ++counter;
                 }
@@ -228,14 +226,14 @@ loop_top:
             break;
         }
 
-        for (i = 0; i < NUM_TOXES_TCP; ++i) {
+        for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
             tox_iterate(toxes[i], &to_comp);
         }
 
         c_sleep(30);
     }
 
-    for (i = 0; i < NUM_TOXES_TCP; ++i) {
+    for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) {
         tox_kill(toxes[i]);
     }
 

external/toxcore/c-toxcore/auto_tests/tox_strncasecmp_test.c

@@ -10,7 +10,7 @@ typedef enum {
     POSITIVE
 } Comparison;
 
-static const char *Comparison_Str[] = { "NEGATIVE", "ZERO", "POSITIVE" };
+static const char *comparison_str[] = { "NEGATIVE", "ZERO", "POSITIVE" };
 
 static void verify(const char *s1, const char *s2, size_t n, Comparison expected)
 {
@@ -19,7 +19,7 @@ static void verify(const char *s1, const char *s2, size_t n, Comparison expected
 
     ck_assert_msg(actual == expected,
                   "tox_strncasecmp(\"%s\", \"%s\", %u) == %s, but expected %s.",
-                  s1, s2, (unsigned)n, Comparison_Str[actual], Comparison_Str[expected]);
+                  s1, s2, (unsigned)n, comparison_str[actual], comparison_str[expected]);
 }
 
 static void test_general(void)

external/toxcore/c-toxcore/auto_tests/toxav_basic_test.c

@@ -93,67 +93,67 @@ static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const
 /**
  * Iterate helper
  */
-static void iterate_tox(Tox *bootstrap, Tox *Alice, Tox *Bob)
+static void iterate_tox(Tox *bootstrap, Tox *alice, Tox *bob)
 {
     c_sleep(100);
     tox_iterate(bootstrap, nullptr);
-    tox_iterate(Alice, nullptr);
-    tox_iterate(Bob, nullptr);
+    tox_iterate(alice, nullptr);
+    tox_iterate(bob, nullptr);
 }
 
 static bool toxav_audio_send_frame_helper(ToxAV *av, uint32_t friend_number, Toxav_Err_Send_Frame *error)
 {
-    static const int16_t PCM[960] = {0};
-    return toxav_audio_send_frame(av, 0, PCM, 960, 1, 48000, nullptr);
+    static const int16_t pcm[960] = {0};
+    return toxav_audio_send_frame(av, 0, pcm, 960, 1, 48000, nullptr);
 }
 
 static void regular_call_flow(
-    Tox *Alice, Tox *Bob, Tox *bootstrap,
-    ToxAV *AliceAV, ToxAV *BobAV,
-    CallControl *AliceCC, CallControl *BobCC,
+    Tox *alice, Tox *bob, Tox *bootstrap,
+    ToxAV *alice_av, ToxAV *bob_av,
+    CallControl *alice_cc, CallControl *bob_cc,
     int a_br, int v_br)
 {
-    clear_call_control(AliceCC);
-    clear_call_control(BobCC);
+    clear_call_control(alice_cc);
+    clear_call_control(bob_cc);
 
     Toxav_Err_Call call_err;
-    toxav_call(AliceAV, 0, a_br, v_br, &call_err);
+    toxav_call(alice_av, 0, a_br, v_br, &call_err);
 
     ck_assert_msg(call_err == TOXAV_ERR_CALL_OK, "toxav_call failed: %d\n", call_err);
 
     const time_t start_time = time(nullptr);
 
     do {
-        if (BobCC->incoming) {
+        if (bob_cc->incoming) {
             Toxav_Err_Answer answer_err;
-            toxav_answer(BobAV, 0, a_br, v_br, &answer_err);
+            toxav_answer(bob_av, 0, a_br, v_br, &answer_err);
 
             ck_assert_msg(answer_err == TOXAV_ERR_ANSWER_OK, "toxav_answer failed: %d\n", answer_err);
 
-            BobCC->incoming = false;
+            bob_cc->incoming = false;
         } else { /* TODO(mannol): rtp */
             if (time(nullptr) - start_time >= 1) {
 
                 Toxav_Err_Call_Control cc_err;
-                toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
+                toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
 
                 ck_assert_msg(cc_err == TOXAV_ERR_CALL_CONTROL_OK, "toxav_call_control failed: %d\n", cc_err);
             }
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
-    } while (BobCC->state != TOXAV_FRIEND_CALL_STATE_FINISHED);
+        iterate_tox(bootstrap, alice, bob);
+    } while (bob_cc->state != TOXAV_FRIEND_CALL_STATE_FINISHED);
 
     printf("Success!\n");
 }
 
 static void test_av_flows(void)
 {
-    Tox *Alice, *Bob, *bootstrap;
-    ToxAV *AliceAV, *BobAV;
+    Tox *alice, *bob, *bootstrap;
+    ToxAV *alice_av, *bob_av;
     uint32_t index[] = { 1, 2, 3 };
 
-    CallControl AliceCC, BobCC;
+    CallControl alice_cc, bob_cc;
 
     {
         Tox_Err_New error;
@@ -161,10 +161,10 @@ static void test_av_flows(void)
         bootstrap = tox_new_log(nullptr, &error, &index[0]);
         ck_assert(error == TOX_ERR_NEW_OK);
 
-        Alice = tox_new_log(nullptr, &error, &index[1]);
+        alice = tox_new_log(nullptr, &error, &index[1]);
         ck_assert(error == TOX_ERR_NEW_OK);
 
-        Bob = tox_new_log(nullptr, &error, &index[2]);
+        bob = tox_new_log(nullptr, &error, &index[2]);
         ck_assert(error == TOX_ERR_NEW_OK);
     }
 
@@ -174,33 +174,33 @@ static void test_av_flows(void)
 
     uint8_t address[TOX_ADDRESS_SIZE];
 
-    tox_callback_friend_request(Alice, t_accept_friend_request_cb);
-    tox_self_get_address(Alice, address);
+    tox_callback_friend_request(alice, t_accept_friend_request_cb);
+    tox_self_get_address(alice, address);
 
     printf("bootstrapping Alice and Bob off a third bootstrap node\n");
     uint8_t dht_key[TOX_PUBLIC_KEY_SIZE];
     tox_self_get_dht_id(bootstrap, dht_key);
     const uint16_t dht_port = tox_self_get_udp_port(bootstrap, nullptr);
 
-    tox_bootstrap(Alice, "localhost", dht_port, dht_key, nullptr);
-    tox_bootstrap(Bob, "localhost", dht_port, dht_key, nullptr);
+    tox_bootstrap(alice, "localhost", dht_port, dht_key, nullptr);
+    tox_bootstrap(bob, "localhost", dht_port, dht_key, nullptr);
 
-    ck_assert(tox_friend_add(Bob, address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
+    ck_assert(tox_friend_add(bob, address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
 
     uint8_t off = 1;
 
     while (true) {
-        iterate_tox(bootstrap, Alice, Bob);
+        iterate_tox(bootstrap, alice, bob);
 
         if (tox_self_get_connection_status(bootstrap) &&
-                tox_self_get_connection_status(Alice) &&
-                tox_self_get_connection_status(Bob) && off) {
+                tox_self_get_connection_status(alice) &&
+                tox_self_get_connection_status(bob) && off) {
             printf("Toxes are online, took %llu seconds\n", time(nullptr) - cur_time);
             off = 0;
         }
 
-        if (tox_friend_get_connection_status(Alice, 0, nullptr) == TOX_CONNECTION_UDP &&
-                tox_friend_get_connection_status(Bob, 0, nullptr) == TOX_CONNECTION_UDP) {
+        if (tox_friend_get_connection_status(alice, 0, nullptr) == TOX_CONNECTION_UDP &&
+                tox_friend_get_connection_status(bob, 0, nullptr) == TOX_CONNECTION_UDP) {
             break;
         }
 
@@ -210,72 +210,72 @@ static void test_av_flows(void)
 
     {
         Toxav_Err_New error;
-        AliceAV = toxav_new(Alice, &error);
+        alice_av = toxav_new(alice, &error);
         ck_assert(error == TOXAV_ERR_NEW_OK);
 
-        BobAV = toxav_new(Bob, &error);
+        bob_av = toxav_new(bob, &error);
         ck_assert(error == TOXAV_ERR_NEW_OK);
     }
 
-    toxav_callback_call(AliceAV, t_toxav_call_cb, &AliceCC);
-    toxav_callback_call_state(AliceAV, t_toxav_call_state_cb, &AliceCC);
-    toxav_callback_video_receive_frame(AliceAV, t_toxav_receive_video_frame_cb, &AliceCC);
-    toxav_callback_audio_receive_frame(AliceAV, t_toxav_receive_audio_frame_cb, &AliceCC);
+    toxav_callback_call(alice_av, t_toxav_call_cb, &alice_cc);
+    toxav_callback_call_state(alice_av, t_toxav_call_state_cb, &alice_cc);
+    toxav_callback_video_receive_frame(alice_av, t_toxav_receive_video_frame_cb, &alice_cc);
+    toxav_callback_audio_receive_frame(alice_av, t_toxav_receive_audio_frame_cb, &alice_cc);
 
-    toxav_callback_call(BobAV, t_toxav_call_cb, &BobCC);
-    toxav_callback_call_state(BobAV, t_toxav_call_state_cb, &BobCC);
-    toxav_callback_video_receive_frame(BobAV, t_toxav_receive_video_frame_cb, &BobCC);
-    toxav_callback_audio_receive_frame(BobAV, t_toxav_receive_audio_frame_cb, &BobCC);
+    toxav_callback_call(bob_av, t_toxav_call_cb, &bob_cc);
+    toxav_callback_call_state(bob_av, t_toxav_call_state_cb, &bob_cc);
+    toxav_callback_video_receive_frame(bob_av, t_toxav_receive_video_frame_cb, &bob_cc);
+    toxav_callback_audio_receive_frame(bob_av, t_toxav_receive_audio_frame_cb, &bob_cc);
 
     printf("Created 2 instances of ToxAV\n");
     printf("All set after %llu seconds!\n", time(nullptr) - cur_time);
 
     if (TEST_REGULAR_AV) {
         printf("\nTrying regular call (Audio and Video)...\n");
-        regular_call_flow(Alice, Bob, bootstrap, AliceAV, BobAV, &AliceCC, &BobCC,
+        regular_call_flow(alice, bob, bootstrap, alice_av, bob_av, &alice_cc, &bob_cc,
                           48, 4000);
     }
 
     if (TEST_REGULAR_A) {
         printf("\nTrying regular call (Audio only)...\n");
-        regular_call_flow(Alice, Bob, bootstrap, AliceAV, BobAV, &AliceCC, &BobCC,
+        regular_call_flow(alice, bob, bootstrap, alice_av, bob_av, &alice_cc, &bob_cc,
                           48, 0);
     }
 
     if (TEST_REGULAR_V) {
         printf("\nTrying regular call (Video only)...\n");
-        regular_call_flow(Alice, Bob, bootstrap, AliceAV, BobAV, &AliceCC, &BobCC,
+        regular_call_flow(alice, bob, bootstrap, alice_av, bob_av, &alice_cc, &bob_cc,
                           0, 4000);
     }
 
     if (TEST_REJECT) { /* Alice calls; Bob rejects */
         printf("\nTrying reject flow...\n");
 
-        clear_call_control(&AliceCC);
-        clear_call_control(&BobCC);
+        clear_call_control(&alice_cc);
+        clear_call_control(&bob_cc);
 
         {
             Toxav_Err_Call rc;
-            toxav_call(AliceAV, 0, 48, 0, &rc);
+            toxav_call(alice_av, 0, 48, 0, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_OK, "toxav_call failed: %d\n", rc);
         }
 
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (!BobCC.incoming);
+            iterate_tox(bootstrap, alice, bob);
+        } while (!bob_cc.incoming);
 
         /* Reject */
         {
             Toxav_Err_Call_Control rc;
-            toxav_call_control(BobAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            toxav_call_control(bob_av, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_CONTROL_OK, "toxav_call_control failed: %d\n", rc);
         }
 
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (AliceCC.state != TOXAV_FRIEND_CALL_STATE_FINISHED);
+            iterate_tox(bootstrap, alice, bob);
+        } while (alice_cc.state != TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
     }
@@ -283,32 +283,32 @@ static void test_av_flows(void)
     if (TEST_CANCEL) { /* Alice calls; Alice cancels while ringing */
         printf("\nTrying cancel (while ringing) flow...\n");
 
-        clear_call_control(&AliceCC);
-        clear_call_control(&BobCC);
+        clear_call_control(&alice_cc);
+        clear_call_control(&bob_cc);
 
         {
             Toxav_Err_Call rc;
-            toxav_call(AliceAV, 0, 48, 0, &rc);
+            toxav_call(alice_av, 0, 48, 0, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_OK, "toxav_call failed: %d\n", rc);
         }
 
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (!BobCC.incoming);
+            iterate_tox(bootstrap, alice, bob);
+        } while (!bob_cc.incoming);
 
         /* Cancel */
         {
             Toxav_Err_Call_Control rc;
-            toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_CONTROL_OK, "toxav_call_control failed: %d\n", rc);
         }
 
         /* Alice will not receive end state */
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (BobCC.state != TOXAV_FRIEND_CALL_STATE_FINISHED);
+            iterate_tox(bootstrap, alice, bob);
+        } while (bob_cc.state != TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
     }
@@ -316,80 +316,80 @@ static void test_av_flows(void)
     if (TEST_MUTE_UNMUTE) { /* Check Mute-Unmute etc */
         printf("\nTrying mute functionality...\n");
 
-        clear_call_control(&AliceCC);
-        clear_call_control(&BobCC);
+        clear_call_control(&alice_cc);
+        clear_call_control(&bob_cc);
 
         /* Assume sending audio and video */
         {
             Toxav_Err_Call rc;
-            toxav_call(AliceAV, 0, 48, 1000, &rc);
+            toxav_call(alice_av, 0, 48, 1000, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_OK, "toxav_call failed: %d\n", rc);
         }
 
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (!BobCC.incoming);
+            iterate_tox(bootstrap, alice, bob);
+        } while (!bob_cc.incoming);
 
         /* At first try all stuff while in invalid state */
-        ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE, nullptr));
-        ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME, nullptr));
-        ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, nullptr));
-        ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, nullptr));
-        ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO, nullptr));
-        ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, nullptr));
+        ck_assert(!toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_PAUSE, nullptr));
+        ck_assert(!toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_RESUME, nullptr));
+        ck_assert(!toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO, nullptr));
+        ck_assert(!toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO, nullptr));
+        ck_assert(!toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO, nullptr));
+        ck_assert(!toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, nullptr));
 
         {
             Toxav_Err_Answer rc;
-            toxav_answer(BobAV, 0, 48, 4000, &rc);
+            toxav_answer(bob_av, 0, 48, 4000, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_ANSWER_OK, "toxav_answer failed: %d\n", rc);
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
+        iterate_tox(bootstrap, alice, bob);
 
         /* Pause and Resume */
         printf("Pause and Resume\n");
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state == 0);
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state & (TOXAV_FRIEND_CALL_STATE_SENDING_A | TOXAV_FRIEND_CALL_STATE_SENDING_V));
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_PAUSE);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state == 0);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_RESUME);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state & (TOXAV_FRIEND_CALL_STATE_SENDING_A | TOXAV_FRIEND_CALL_STATE_SENDING_V));
 
         /* Mute/Unmute single */
         printf("Mute/Unmute single\n");
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
 
         /* Mute/Unmute both */
         printf("Mute/Unmute both\n");
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_MUTE_AUDIO);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_HIDE_VIDEO);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state ^ TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_UNMUTE_AUDIO);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
 
         {
             Toxav_Err_Call_Control rc;
-            toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_CONTROL_OK, "toxav_call_control failed: %d\n", rc);
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
     }
@@ -397,58 +397,58 @@ static void test_av_flows(void)
     if (TEST_STOP_RESUME_PAYLOAD) { /* Stop and resume audio/video payload */
         printf("\nTrying stop/resume functionality...\n");
 
-        clear_call_control(&AliceCC);
-        clear_call_control(&BobCC);
+        clear_call_control(&alice_cc);
+        clear_call_control(&bob_cc);
 
         /* Assume sending audio and video */
         {
             Toxav_Err_Call rc;
-            toxav_call(AliceAV, 0, 48, 0, &rc);
+            toxav_call(alice_av, 0, 48, 0, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_OK, "toxav_call failed: %d\n", rc);
         }
 
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (!BobCC.incoming);
+            iterate_tox(bootstrap, alice, bob);
+        } while (!bob_cc.incoming);
 
         {
             Toxav_Err_Answer rc;
-            toxav_answer(BobAV, 0, 48, 0, &rc);
+            toxav_answer(bob_av, 0, 48, 0, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_ANSWER_OK, "toxav_answer failed: %d\n", rc);
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
+        iterate_tox(bootstrap, alice, bob);
 
         printf("Call started as audio only\n");
         printf("Turning on video for Alice...\n");
-        ck_assert(toxav_video_set_bit_rate(AliceAV, 0, 1000, nullptr));
+        ck_assert(toxav_video_set_bit_rate(alice_av, 0, 1000, nullptr));
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_V);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state & TOXAV_FRIEND_CALL_STATE_SENDING_V);
 
         printf("Turning off video for Alice...\n");
-        ck_assert(toxav_video_set_bit_rate(AliceAV, 0, 0, nullptr));
+        ck_assert(toxav_video_set_bit_rate(alice_av, 0, 0, nullptr));
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(!(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_V));
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(!(bob_cc.state & TOXAV_FRIEND_CALL_STATE_SENDING_V));
 
         printf("Turning off audio for Alice...\n");
-        ck_assert(toxav_audio_set_bit_rate(AliceAV, 0, 0, nullptr));
+        ck_assert(toxav_audio_set_bit_rate(alice_av, 0, 0, nullptr));
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(!(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_A));
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(!(bob_cc.state & TOXAV_FRIEND_CALL_STATE_SENDING_A));
 
         {
             Toxav_Err_Call_Control rc;
-            toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_CONTROL_OK, "toxav_call_control failed: %d\n", rc);
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
     }
@@ -456,56 +456,56 @@ static void test_av_flows(void)
     if (TEST_PAUSE_RESUME_SEND) { /* Stop and resume audio/video payload and test send options */
         printf("\nTrying stop/resume functionality...\n");
 
-        clear_call_control(&AliceCC);
-        clear_call_control(&BobCC);
+        clear_call_control(&alice_cc);
+        clear_call_control(&bob_cc);
 
         /* Assume sending audio and video */
         {
             Toxav_Err_Call rc;
-            toxav_call(AliceAV, 0, 48, 0, &rc);
+            toxav_call(alice_av, 0, 48, 0, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_OK, "toxav_call failed: %d\n", rc);
         }
 
         do {
-            iterate_tox(bootstrap, Alice, Bob);
-        } while (!BobCC.incoming);
+            iterate_tox(bootstrap, alice, bob);
+        } while (!bob_cc.incoming);
 
         {
             Toxav_Err_Answer rc;
-            toxav_answer(BobAV, 0, 48, 0, &rc);
+            toxav_answer(bob_av, 0, 48, 0, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_ANSWER_OK, "toxav_answer failed: %d\n", rc);
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_PAUSE);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(!toxav_audio_send_frame_helper(AliceAV, 0, nullptr));
-        ck_assert(!toxav_audio_send_frame_helper(BobAV, 0, nullptr));
-        ck_assert_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_RESUME);
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(toxav_audio_send_frame_helper(AliceAV, 0, nullptr));
-        ck_assert(toxav_audio_send_frame_helper(BobAV, 0, nullptr));
-        iterate_tox(bootstrap, Alice, Bob);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_PAUSE);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(!toxav_audio_send_frame_helper(alice_av, 0, nullptr));
+        ck_assert(!toxav_audio_send_frame_helper(bob_av, 0, nullptr));
+        ck_assert_call_control(alice_av, 0, TOXAV_CALL_CONTROL_RESUME);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(toxav_audio_send_frame_helper(alice_av, 0, nullptr));
+        ck_assert(toxav_audio_send_frame_helper(bob_av, 0, nullptr));
+        iterate_tox(bootstrap, alice, bob);
 
         {
             Toxav_Err_Call_Control rc;
-            toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
+            toxav_call_control(alice_av, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
             ck_assert_msg(rc == TOXAV_ERR_CALL_CONTROL_OK, "toxav_call_control failed: %d\n", rc);
         }
 
-        iterate_tox(bootstrap, Alice, Bob);
-        ck_assert(BobCC.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
+        iterate_tox(bootstrap, alice, bob);
+        ck_assert(bob_cc.state == TOXAV_FRIEND_CALL_STATE_FINISHED);
 
         printf("Success!\n");
     }
 
-    toxav_kill(BobAV);
-    toxav_kill(AliceAV);
-    tox_kill(Bob);
-    tox_kill(Alice);
+    toxav_kill(bob_av);
+    toxav_kill(alice_av);
+    tox_kill(bob);
+    tox_kill(alice);
     tox_kill(bootstrap);
 
     printf("\nTest successful!\n");

external/toxcore/c-toxcore/auto_tests/toxav_many_test.c

@@ -21,18 +21,18 @@
 #include "auto_test_support.h"
 #include "check_compat.h"
 
-typedef struct {
+typedef struct CallControl {
     bool incoming;
     uint32_t state;
 } CallControl;
 
-typedef struct {
-    ToxAV *AliceAV;
-    ToxAV *BobAV;
-    CallControl *AliceCC;
-    CallControl *BobCC;
+typedef struct Thread_Data {
+    ToxAV *alice_av;
+    ToxAV *bob_av;
+    CallControl *alice_cc;
+    CallControl *bob_cc;
     uint32_t friend_number;
-} thread_data;
+} Thread_Data;
 
 /**
  * Callbacks
@@ -78,28 +78,28 @@ static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const
 /**
  * Iterate helper
  */
-static ToxAV *setup_av_instance(Tox *tox, CallControl *CC)
+static ToxAV *setup_av_instance(Tox *tox, CallControl *cc)
 {
     Toxav_Err_New error;
 
     ToxAV *av = toxav_new(tox, &error);
     ck_assert(error == TOXAV_ERR_NEW_OK);
 
-    toxav_callback_call(av, t_toxav_call_cb, CC);
-    toxav_callback_call_state(av, t_toxav_call_state_cb, CC);
-    toxav_callback_video_receive_frame(av, t_toxav_receive_video_frame_cb, CC);
-    toxav_callback_audio_receive_frame(av, t_toxav_receive_audio_frame_cb, CC);
+    toxav_callback_call(av, t_toxav_call_cb, cc);
+    toxav_callback_call_state(av, t_toxav_call_state_cb, cc);
+    toxav_callback_video_receive_frame(av, t_toxav_receive_video_frame_cb, cc);
+    toxav_callback_audio_receive_frame(av, t_toxav_receive_audio_frame_cb, cc);
 
     return av;
 }
 
 static void *call_thread(void *pd)
 {
-    ToxAV *AliceAV = ((thread_data *) pd)->AliceAV;
-    ToxAV *BobAV = ((thread_data *) pd)->BobAV;
-    uint32_t friend_number = ((thread_data *) pd)->friend_number;
+    ToxAV *alice_av = ((Thread_Data *) pd)->alice_av;
+    ToxAV *bob_av = ((Thread_Data *) pd)->bob_av;
+    uint32_t friend_number = ((Thread_Data *) pd)->friend_number;
 
-    int16_t *PCM = (int16_t *)calloc(960, sizeof(int16_t));
+    int16_t *pcm = (int16_t *)calloc(960, sizeof(int16_t));
     uint8_t *video_y = (uint8_t *)calloc(800 * 600, sizeof(uint8_t));
     uint8_t *video_u = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));
     uint8_t *video_v = (uint8_t *)calloc(800 * 600 / 4, sizeof(uint8_t));
@@ -107,19 +107,19 @@ static void *call_thread(void *pd)
     time_t start_time = time(nullptr);
 
     do {
-        toxav_iterate(AliceAV);
-        toxav_iterate(BobAV);
+        toxav_iterate(alice_av);
+        toxav_iterate(bob_av);
 
-        toxav_audio_send_frame(AliceAV, friend_number, PCM, 960, 1, 48000, nullptr);
-        toxav_audio_send_frame(BobAV, 0, PCM, 960, 1, 48000, nullptr);
+        toxav_audio_send_frame(alice_av, friend_number, pcm, 960, 1, 48000, nullptr);
+        toxav_audio_send_frame(bob_av, 0, pcm, 960, 1, 48000, nullptr);
 
-        toxav_video_send_frame(AliceAV, friend_number, 800, 600, video_y, video_u, video_v, nullptr);
-        toxav_video_send_frame(BobAV, 0, 800, 600, video_y, video_u, video_v, nullptr);
+        toxav_video_send_frame(alice_av, friend_number, 800, 600, video_y, video_u, video_v, nullptr);
+        toxav_video_send_frame(bob_av, 0, 800, 600, video_y, video_u, video_v, nullptr);
 
         c_sleep(10);
     } while (time(nullptr) - start_time < 4);
 
-    free(PCM);
+    free(pcm);
     free(video_y);
     free(video_u);
     free(video_v);
@@ -160,11 +160,11 @@ static void set_current_time_callback(Tox *tox, Time_Data *time_data)
 static void test_av_three_calls(void)
 {
     uint32_t index[] = { 1, 2, 3, 4, 5 };
-    Tox *Alice, *bootstrap, *Bobs[3];
-    ToxAV *AliceAV, *BobsAV[3];
+    Tox *alice, *bootstrap, *bobs[3];
+    ToxAV *alice_av, *bobs_av[3];
     void *retval;
 
-    CallControl AliceCC[3], BobsCC[3];
+    CallControl alice_cc[3], bobs_cc[3];
 
     Time_Data time_data;
     pthread_mutex_init(&time_data.lock, nullptr);
@@ -177,21 +177,21 @@ static void test_av_three_calls(void)
         time_data.clock = current_time_monotonic(bootstrap->mono_time);
         set_current_time_callback(bootstrap, &time_data);
 
-        Alice = tox_new_log(nullptr, &error, &index[1]);
+        alice = tox_new_log(nullptr, &error, &index[1]);
         ck_assert(error == TOX_ERR_NEW_OK);
-        set_current_time_callback(Alice, &time_data);
+        set_current_time_callback(alice, &time_data);
 
-        Bobs[0] = tox_new_log(nullptr, &error, &index[2]);
+        bobs[0] = tox_new_log(nullptr, &error, &index[2]);
         ck_assert(error == TOX_ERR_NEW_OK);
-        set_current_time_callback(Bobs[0], &time_data);
+        set_current_time_callback(bobs[0], &time_data);
 
-        Bobs[1] = tox_new_log(nullptr, &error, &index[3]);
+        bobs[1] = tox_new_log(nullptr, &error, &index[3]);
         ck_assert(error == TOX_ERR_NEW_OK);
-        set_current_time_callback(Bobs[1], &time_data);
+        set_current_time_callback(bobs[1], &time_data);
 
-        Bobs[2] = tox_new_log(nullptr, &error, &index[4]);
+        bobs[2] = tox_new_log(nullptr, &error, &index[4]);
         ck_assert(error == TOX_ERR_NEW_OK);
-        set_current_time_callback(Bobs[2], &time_data);
+        set_current_time_callback(bobs[2], &time_data);
     }
 
     printf("Created 5 instances of Tox\n");
@@ -200,48 +200,48 @@ static void test_av_three_calls(void)
 
     uint8_t address[TOX_ADDRESS_SIZE];
 
-    tox_callback_friend_request(Alice, t_accept_friend_request_cb);
-    tox_self_get_address(Alice, address);
+    tox_callback_friend_request(alice, t_accept_friend_request_cb);
+    tox_self_get_address(alice, address);
 
     printf("bootstrapping Alice and the %u Bobs off a third bootstrap node\n",
-           (unsigned)(sizeof(Bobs) / sizeof(Bobs[0])));
+           (unsigned)(sizeof(bobs) / sizeof(bobs[0])));
     uint8_t dht_key[TOX_PUBLIC_KEY_SIZE];
     tox_self_get_dht_id(bootstrap, dht_key);
     const uint16_t dht_port = tox_self_get_udp_port(bootstrap, nullptr);
 
-    tox_bootstrap(Alice, "localhost", dht_port, dht_key, nullptr);
-    tox_bootstrap(Bobs[0], "localhost", dht_port, dht_key, nullptr);
-    tox_bootstrap(Bobs[1], "localhost", dht_port, dht_key, nullptr);
-    tox_bootstrap(Bobs[2], "localhost", dht_port, dht_key, nullptr);
+    tox_bootstrap(alice, "localhost", dht_port, dht_key, nullptr);
+    tox_bootstrap(bobs[0], "localhost", dht_port, dht_key, nullptr);
+    tox_bootstrap(bobs[1], "localhost", dht_port, dht_key, nullptr);
+    tox_bootstrap(bobs[2], "localhost", dht_port, dht_key, nullptr);
 
-    ck_assert(tox_friend_add(Bobs[0], address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
-    ck_assert(tox_friend_add(Bobs[1], address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
-    ck_assert(tox_friend_add(Bobs[2], address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
+    ck_assert(tox_friend_add(bobs[0], address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
+    ck_assert(tox_friend_add(bobs[1], address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
+    ck_assert(tox_friend_add(bobs[2], address, (const uint8_t *)"gentoo", 7, nullptr) != (uint32_t) -1);
 
     uint8_t off = 1;
 
     while (true) {
         tox_iterate(bootstrap, nullptr);
-        tox_iterate(Alice, nullptr);
-        tox_iterate(Bobs[0], nullptr);
-        tox_iterate(Bobs[1], nullptr);
-        tox_iterate(Bobs[2], nullptr);
+        tox_iterate(alice, nullptr);
+        tox_iterate(bobs[0], nullptr);
+        tox_iterate(bobs[1], nullptr);
+        tox_iterate(bobs[2], nullptr);
 
         if (tox_self_get_connection_status(bootstrap) &&
-                tox_self_get_connection_status(Alice) &&
-                tox_self_get_connection_status(Bobs[0]) &&
-                tox_self_get_connection_status(Bobs[1]) &&
-                tox_self_get_connection_status(Bobs[2]) && off) {
+                tox_self_get_connection_status(alice) &&
+                tox_self_get_connection_status(bobs[0]) &&
+                tox_self_get_connection_status(bobs[1]) &&
+                tox_self_get_connection_status(bobs[2]) && off) {
             printf("Toxes are online, took %lu seconds\n", (unsigned long)(time(nullptr) - cur_time));
             off = 0;
         }
 
-        if (tox_friend_get_connection_status(Alice, 0, nullptr) == TOX_CONNECTION_UDP &&
-                tox_friend_get_connection_status(Alice, 1, nullptr) == TOX_CONNECTION_UDP &&
-                tox_friend_get_connection_status(Alice, 2, nullptr) == TOX_CONNECTION_UDP &&
-                tox_friend_get_connection_status(Bobs[0], 0, nullptr) == TOX_CONNECTION_UDP &&
-                tox_friend_get_connection_status(Bobs[1], 0, nullptr) == TOX_CONNECTION_UDP &&
-                tox_friend_get_connection_status(Bobs[2], 0, nullptr) == TOX_CONNECTION_UDP) {
+        if (tox_friend_get_connection_status(alice, 0, nullptr) == TOX_CONNECTION_UDP &&
+                tox_friend_get_connection_status(alice, 1, nullptr) == TOX_CONNECTION_UDP &&
+                tox_friend_get_connection_status(alice, 2, nullptr) == TOX_CONNECTION_UDP &&
+                tox_friend_get_connection_status(bobs[0], 0, nullptr) == TOX_CONNECTION_UDP &&
+                tox_friend_get_connection_status(bobs[1], 0, nullptr) == TOX_CONNECTION_UDP &&
+                tox_friend_get_connection_status(bobs[2], 0, nullptr) == TOX_CONNECTION_UDP) {
             break;
         }
 
@@ -249,24 +249,24 @@ static void test_av_three_calls(void)
         c_sleep(5);
     }
 
-    AliceAV = setup_av_instance(Alice, AliceCC);
-    BobsAV[0] = setup_av_instance(Bobs[0], &BobsCC[0]);
-    BobsAV[1] = setup_av_instance(Bobs[1], &BobsCC[1]);
-    BobsAV[2] = setup_av_instance(Bobs[2], &BobsCC[2]);
+    alice_av = setup_av_instance(alice, alice_cc);
+    bobs_av[0] = setup_av_instance(bobs[0], &bobs_cc[0]);
+    bobs_av[1] = setup_av_instance(bobs[1], &bobs_cc[1]);
+    bobs_av[2] = setup_av_instance(bobs[2], &bobs_cc[2]);
 
     printf("Created 4 instances of ToxAV\n");
     printf("All set after %lu seconds!\n", (unsigned long)(time(nullptr) - cur_time));
 
-    thread_data tds[3];
+    Thread_Data tds[3];
 
     for (size_t i = 0; i < 3; i++) {
-        tds[i].AliceAV = AliceAV;
-        tds[i].BobAV = BobsAV[i];
-        tds[i].AliceCC = &AliceCC[i];
-        tds[i].BobCC = &BobsCC[i];
+        tds[i].alice_av = alice_av;
+        tds[i].bob_av = bobs_av[i];
+        tds[i].alice_cc = &alice_cc[i];
+        tds[i].bob_cc = &bobs_cc[i];
         tds[i].friend_number = i;
-        memset(tds[i].AliceCC, 0, sizeof(CallControl));
-        memset(tds[i].BobCC, 0, sizeof(CallControl));
+        memset(tds[i].alice_cc, 0, sizeof(CallControl));
+        memset(tds[i].bob_cc, 0, sizeof(CallControl));
     }
 
     pthread_t tids[3];
@@ -279,10 +279,10 @@ static void test_av_three_calls(void)
 
     do {
         tox_iterate(bootstrap, nullptr);
-        tox_iterate(Alice, nullptr);
-        tox_iterate(Bobs[0], nullptr);
-        tox_iterate(Bobs[1], nullptr);
-        tox_iterate(Bobs[2], nullptr);
+        tox_iterate(alice, nullptr);
+        tox_iterate(bobs[0], nullptr);
+        tox_iterate(bobs[1], nullptr);
+        tox_iterate(bobs[2], nullptr);
 
         increment_clock(&time_data, 100);
         c_sleep(5);
@@ -291,7 +291,7 @@ static void test_av_three_calls(void)
     /* Call */
     for (size_t i = 0; i < 3; i++) {
         Toxav_Err_Call rc;
-        toxav_call(AliceAV, tds[i].friend_number, 48, 3000, &rc);
+        toxav_call(alice_av, tds[i].friend_number, 48, 3000, &rc);
 
         if (rc != TOXAV_ERR_CALL_OK) {
             printf("toxav_call failed: %d\n", rc);
@@ -302,23 +302,23 @@ static void test_av_three_calls(void)
 
     do {
         tox_iterate(bootstrap, nullptr);
-        tox_iterate(Alice, nullptr);
-        tox_iterate(Bobs[0], nullptr);
-        tox_iterate(Bobs[1], nullptr);
-        tox_iterate(Bobs[2], nullptr);
+        tox_iterate(alice, nullptr);
+        tox_iterate(bobs[0], nullptr);
+        tox_iterate(bobs[1], nullptr);
+        tox_iterate(bobs[2], nullptr);
 
         for (size_t i = 0; i < 3; i++) {
-            if (BobsCC[i].incoming) {
+            if (bobs_cc[i].incoming) {
                 /* Answer */
                 Toxav_Err_Answer rc;
-                toxav_answer(BobsAV[i], 0, 8, 500, &rc);
+                toxav_answer(bobs_av[i], 0, 8, 500, &rc);
 
                 if (rc != TOXAV_ERR_ANSWER_OK) {
                     printf("toxav_answer failed: %d\n", rc);
                     ck_assert(0);
                 }
 
-                BobsCC[i].incoming = false;
+                bobs_cc[i].incoming = false;
             }
         }
 
@@ -329,19 +329,19 @@ static void test_av_three_calls(void)
     /* Hangup */
     for (size_t i = 0; i < 3; i++) {
         Toxav_Err_Call_Control rc;
-        toxav_call_control(AliceAV, i, TOXAV_CALL_CONTROL_CANCEL, &rc);
+        toxav_call_control(alice_av, i, TOXAV_CALL_CONTROL_CANCEL, &rc);
 
         if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
-            printf("toxav_call_control failed: %d %p %p\n", rc, (void *)AliceAV, (void *)&BobsAV[i]);
+            printf("toxav_call_control failed: %d %p %p\n", rc, (void *)alice_av, (void *)&bobs_av[i]);
         }
     }
 
     do {
         tox_iterate(bootstrap, nullptr);
-        tox_iterate(Alice, nullptr);
-        tox_iterate(Bobs[0], nullptr);
-        tox_iterate(Bobs[1], nullptr);
-        tox_iterate(Bobs[2], nullptr);
+        tox_iterate(alice, nullptr);
+        tox_iterate(bobs[0], nullptr);
+        tox_iterate(bobs[1], nullptr);
+        tox_iterate(bobs[2], nullptr);
 
         increment_clock(&time_data, 100);
         c_sleep(5);
@@ -357,14 +357,14 @@ static void test_av_three_calls(void)
     ck_assert(retval == nullptr);
 
     printf("Killing all instances\n");
-    toxav_kill(BobsAV[2]);
-    toxav_kill(BobsAV[1]);
-    toxav_kill(BobsAV[0]);
-    toxav_kill(AliceAV);
-    tox_kill(Bobs[2]);
-    tox_kill(Bobs[1]);
-    tox_kill(Bobs[0]);
-    tox_kill(Alice);
+    toxav_kill(bobs_av[2]);
+    toxav_kill(bobs_av[1]);
+    toxav_kill(bobs_av[0]);
+    toxav_kill(alice_av);
+    tox_kill(bobs[2]);
+    tox_kill(bobs[1]);
+    tox_kill(bobs[0]);
+    tox_kill(alice);
     tox_kill(bootstrap);
 
     pthread_mutex_destroy(&time_data.lock);

external/toxcore/c-toxcore/auto_tests/version_test.c

@@ -1,7 +1,7 @@
 #include "../toxcore/tox.h"
 #include "check_compat.h"
 
-#define check(major, minor, patch, expected)                            \
+#define CHECK(major, minor, patch, expected)                            \
   do_check(TOX_VERSION_MAJOR, TOX_VERSION_MINOR, TOX_VERSION_PATCH,     \
            major, minor, patch,                                         \
            TOX_VERSION_IS_API_COMPATIBLE(major, minor, patch), expected)
@@ -26,11 +26,11 @@ int main(void)
 #define TOX_VERSION_MINOR 0
 #define TOX_VERSION_PATCH 4
     // Tox versions from 0.0.* are only compatible with themselves.
-    check(0, 0, 0, false);
-    check(0, 0, 3, false);
-    check(0, 0, 4, true);
-    check(0, 0, 5, false);
-    check(1, 0, 4, false);
+    CHECK(0, 0, 0, false);
+    CHECK(0, 0, 3, false);
+    CHECK(0, 0, 4, true);
+    CHECK(0, 0, 5, false);
+    CHECK(1, 0, 4, false);
 #undef TOX_VERSION_MAJOR
 #undef TOX_VERSION_MINOR
 #undef TOX_VERSION_PATCH
@@ -39,19 +39,19 @@ int main(void)
 #define TOX_VERSION_MINOR 1
 #define TOX_VERSION_PATCH 4
     // Tox versions from 0.1.* are only compatible with themselves or 0.1.<*
-    check(0, 0, 0, false);
-    check(0, 0, 4, false);
-    check(0, 0, 5, false);
-    check(0, 1, 0, true);
-    check(0, 1, 4, true);
-    check(0, 1, 5, false);
-    check(0, 2, 0, false);
-    check(0, 2, 4, false);
-    check(0, 2, 5, false);
-    check(1, 0, 0, false);
-    check(1, 0, 4, false);
-    check(1, 0, 5, false);
-    check(1, 1, 4, false);
+    CHECK(0, 0, 0, false);
+    CHECK(0, 0, 4, false);
+    CHECK(0, 0, 5, false);
+    CHECK(0, 1, 0, true);
+    CHECK(0, 1, 4, true);
+    CHECK(0, 1, 5, false);
+    CHECK(0, 2, 0, false);
+    CHECK(0, 2, 4, false);
+    CHECK(0, 2, 5, false);
+    CHECK(1, 0, 0, false);
+    CHECK(1, 0, 4, false);
+    CHECK(1, 0, 5, false);
+    CHECK(1, 1, 4, false);
 #undef TOX_VERSION_MAJOR
 #undef TOX_VERSION_MINOR
 #undef TOX_VERSION_PATCH
@@ -60,14 +60,14 @@ int main(void)
 #define TOX_VERSION_MINOR 0
 #define TOX_VERSION_PATCH 4
     // Beyond 0.*.* Tox is comfortable with any lower version within their major
-    check(0, 0, 4, false);
-    check(1, 0, 0, true);
-    check(1, 0, 1, true);
-    check(1, 0, 4, true);
-    check(1, 0, 5, false);
-    check(1, 1, 0, false);
-    check(2, 0, 0, false);
-    check(2, 0, 4, false);
+    CHECK(0, 0, 4, false);
+    CHECK(1, 0, 0, true);
+    CHECK(1, 0, 1, true);
+    CHECK(1, 0, 4, true);
+    CHECK(1, 0, 5, false);
+    CHECK(1, 1, 0, false);
+    CHECK(2, 0, 0, false);
+    CHECK(2, 0, 4, false);
 #undef TOX_VERSION_MAJOR
 #undef TOX_VERSION_MINOR
 #undef TOX_VERSION_PATCH
@@ -75,19 +75,19 @@ int main(void)
 #define TOX_VERSION_MAJOR 1
 #define TOX_VERSION_MINOR 1
 #define TOX_VERSION_PATCH 4
-    check(0, 0, 4, false);
-    check(1, 0, 0, true);
-    check(1, 0, 4, true);
-    check(1, 0, 5, true);
-    check(1, 1, 0, true);
-    check(1, 1, 1, true);
-    check(1, 1, 4, true);
-    check(1, 1, 5, false);
-    check(1, 2, 0, false);
-    check(1, 2, 4, false);
-    check(1, 2, 5, false);
-    check(2, 0, 0, false);
-    check(2, 1, 4, false);
+    CHECK(0, 0, 4, false);
+    CHECK(1, 0, 0, true);
+    CHECK(1, 0, 4, true);
+    CHECK(1, 0, 5, true);
+    CHECK(1, 1, 0, true);
+    CHECK(1, 1, 1, true);
+    CHECK(1, 1, 4, true);
+    CHECK(1, 1, 5, false);
+    CHECK(1, 2, 0, false);
+    CHECK(1, 2, 4, false);
+    CHECK(1, 2, 5, false);
+    CHECK(2, 0, 0, false);
+    CHECK(2, 1, 4, false);
 #undef TOX_VERSION_MAJOR
 #undef TOX_VERSION_MINOR
 #undef TOX_VERSION_PATCH

external/toxcore/c-toxcore/azure-pipelines.yml

@@ -0,0 +1,15 @@
+pool:
+  vmImage: "windows-2019"
+jobs:
+  - job: "windows_msvc_conan"
+    strategy:
+      matrix:
+        static:
+          conan.shared: "False"
+        shared:
+          conan.shared: "True"
+    steps:
+      - bash: python -m pip install conan==1.59.0
+      - bash: git submodule update --init --recursive
+      - bash: conan install -if _build -o with_tests=True -o shared=$(conan.shared) .
+      - bash: CONAN_CPU_COUNT=50 CTEST_OUTPUT_ON_FAILURE=1 conan build -bf _build -if _build . || true

external/toxcore/c-toxcore/cmake/StrictAbi.cmake

@@ -29,7 +29,7 @@ function(_make_version_script target)
     list(GET sublib 1 ns)
 
     execute_process(
-      COMMAND ${SHELL} -c "egrep '^\\w' ${header} | grep '${ns}_[a-z0-9_]*(' | grep -v '^typedef' | grep -o '${ns}_[a-z0-9_]*(' | egrep -o '\\w+' | sort -u"
+      COMMAND ${SHELL} -c "egrep '^\\w' ${header} | grep '${ns}_[a-z0-9_]*(' | grep -v '^typedef' | grep -o '${ns}_[a-z0-9_]*(' | egrep -o '[a-z0-9_]+' | sort -u"
       OUTPUT_VARIABLE sublib_SYMS
       OUTPUT_STRIP_TRAILING_WHITESPACE)
     string(REPLACE "\n" ";" sublib_SYMS ${sublib_SYMS})

external/toxcore/c-toxcore/codecov.yml

@@ -11,3 +11,7 @@ coverage:
         # because of the above range, but toxcore coverage fluctuates a lot due
         # to low coverage of error paths that sometimes happen.
         threshold: 2%
+
+ignore:
+  - "auto_tests" # ignore tests in coverage analysis
+  - "other" # we don't test the bootstrap daemon

external/toxcore/c-toxcore/conanfile.py

@@ -36,6 +36,7 @@ class ToxConan(ConanFile):
         self._cmake = CMake(self)
         self._cmake.definitions["AUTOTEST"] = self.options.with_tests
         self._cmake.definitions["BUILD_MISC_TESTS"] = self.options.with_tests
+        self._cmake.definitions["TEST_TIMEOUT_SECONDS"] = "300"
 
         self._cmake.definitions[
             "CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS"] = self.options.shared

external/toxcore/c-toxcore/docs/Doxyfile

@@ -1614,17 +1614,6 @@ HTML_FORMULA_FORMAT    = png
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
 # The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
 # to create new LaTeX commands to be used in formulas as building blocks. See
 # the section "Including formulas" for details.
@@ -2307,15 +2296,6 @@ EXTERNAL_PAGES         = YES
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
@@ -2348,23 +2328,6 @@ HAVE_DOT               = NO
 
 DOT_NUM_THREADS        = 0
 
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
 # By default doxygen will tell dot to use the default font as specified with
 # DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
 # the path where dot can find it using this tag.
@@ -2599,18 +2562,6 @@ DOT_GRAPH_MAX_NODES    = 50
 
 MAX_DOT_GRAPH_DEPTH    = 0
 
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10) support

external/toxcore/c-toxcore/other/BUILD.bazel

@@ -1,8 +1,6 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary")
 load("//tools:no_undefined.bzl", "cc_library")
 
-package(features = ["layering_check"])
-
 cc_library(
     name = "bootstrap_node_packets",
     srcs = ["bootstrap_node_packets.c"],
@@ -16,6 +14,7 @@ cc_binary(
     testonly = 1,
     srcs = ["DHT_bootstrap.c"],
     deps = [
+        ":bootstrap_node_packets",
         "//c-toxcore/testing:misc_tools",
         "//c-toxcore/toxcore:DHT",
         "//c-toxcore/toxcore:LAN_discovery",

external/toxcore/c-toxcore/other/DHT_bootstrap.c

@@ -31,11 +31,16 @@
 
 #include "../testing/misc_tools.h"
 
+#define DHT_NODE_EXTRA_PACKETS
+
 #ifdef DHT_NODE_EXTRA_PACKETS
 #include "./bootstrap_node_packets.h"
 
-#define DHT_VERSION_NUMBER 1
-#define DHT_MOTD "This is a test motd"
+#ifndef DAEMON_VERSION_NUMBER
+#define DAEMON_VERSION_NUMBER (1000000000UL + TOX_VERSION_MAJOR*1000000UL + TOX_VERSION_MINOR*1000UL + TOX_VERSION_PATCH*1UL)
+#endif
+
+static const char *motd_str = ""; //Change this to anything within 256 bytes(but 96 bytes maximum prefered)
 #endif
 
 #define PORT 33445
@@ -82,38 +87,33 @@ static void manage_keys(DHT *dht)
     fclose(keys_file);
 }
 
+static const char *strlevel(Logger_Level level)
+{
+    switch (level) {
+        case LOGGER_LEVEL_TRACE:
+            return "TRACE";
+
+        case LOGGER_LEVEL_DEBUG:
+            return "DEBUG";
+
+        case LOGGER_LEVEL_INFO:
+            return "INFO";
+
+        case LOGGER_LEVEL_WARNING:
+            return "WARNING";
+
+        case LOGGER_LEVEL_ERROR:
+            return "ERROR";
+
+        default:
+            return "<unknown>";
+    }
+}
+
 static void print_log(void *context, Logger_Level level, const char *file, int line,
                       const char *func, const char *message, void *userdata)
 {
-    const char *strlevel;
-
-    switch (level) {
-        case LOGGER_LEVEL_TRACE:
-            strlevel = "TRACE";
-            break;
-
-        case LOGGER_LEVEL_DEBUG:
-            strlevel = "DEBUG";
-            break;
-
-        case LOGGER_LEVEL_INFO:
-            strlevel = "INFO";
-            break;
-
-        case LOGGER_LEVEL_WARNING:
-            strlevel = "WARNING";
-            break;
-
-        case LOGGER_LEVEL_ERROR:
-            strlevel = "ERROR";
-            break;
-
-        default:
-            strlevel = "<unknown>";
-            break;
-    }
-
-    fprintf(stderr, "[%s] %s:%d(%s) %s\n", strlevel, file, line, func, message);
+    fprintf(stderr, "[%s] %s:%d(%s) %s\n", strlevel(level), file, line, func, message);
 }
 
 int main(int argc, char *argv[])
@@ -139,23 +139,25 @@ int main(int argc, char *argv[])
 
     Logger *logger = logger_new();
 
-    if (MIN_LOGGER_LEVEL == LOGGER_LEVEL_TRACE || MIN_LOGGER_LEVEL == LOGGER_LEVEL_DEBUG) {
+    if (MIN_LOGGER_LEVEL <= LOGGER_LEVEL_DEBUG) {
         logger_callback_log(logger, print_log, nullptr, nullptr);
     }
 
     const Random *rng = system_random();
-    Mono_Time *mono_time = mono_time_new(nullptr, nullptr);
+    const Network *ns = system_network();
+    const Memory *mem = system_memory();
+
+    Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
     const uint16_t start_port = PORT;
     const uint16_t end_port = start_port + (TOX_PORTRANGE_TO - TOX_PORTRANGE_FROM);
-    const Network *ns = system_network();
-    DHT *dht = new_dht(logger, rng, ns, mono_time, new_networking_ex(logger, ns, &ip, start_port, end_port, nullptr), true, true);
-    Onion *onion = new_onion(logger, mono_time, rng, dht);
+    DHT *dht = new_dht(logger, mem, rng, ns, mono_time, new_networking_ex(logger, mem, ns, &ip, start_port, end_port, nullptr), true, true);
+    Onion *onion = new_onion(logger, mem, mono_time, rng, dht);
     Forwarding *forwarding = new_forwarding(logger, rng, mono_time, dht);
     GC_Announces_List *gc_announces_list = new_gca_list();
-    Onion_Announce *onion_a = new_onion_announce(logger, rng, mono_time, dht);
+    Onion_Announce *onion_a = new_onion_announce(logger, mem, rng, mono_time, dht);
 
 #ifdef DHT_NODE_EXTRA_PACKETS
-    bootstrap_set_callbacks(dht_get_net(dht), DHT_VERSION_NUMBER, DHT_MOTD, sizeof(DHT_MOTD));
+    bootstrap_set_callbacks(dht_get_net(dht), (uint32_t)DAEMON_VERSION_NUMBER, (const uint8_t *) motd_str, strlen(motd_str)+1);
 #endif
 
     if (!(onion && forwarding && onion_a)) {
@@ -173,7 +175,7 @@ int main(int argc, char *argv[])
 #ifdef TCP_RELAY_ENABLED
 #define NUM_PORTS 3
     uint16_t ports[NUM_PORTS] = {443, 3389, PORT};
-    TCP_Server *tcp_s = new_TCP_server(logger, rng, ns, ipv6enabled, NUM_PORTS, ports, dht_get_self_secret_key(dht), onion, forwarding);
+    TCP_Server *tcp_s = new_tcp_server(logger, mem, rng, ns, ipv6enabled, NUM_PORTS, ports, dht_get_self_secret_key(dht), onion, forwarding);
 
     if (tcp_s == nullptr) {
         printf("TCP server failed to initialize.\n");
@@ -226,7 +228,7 @@ int main(int argc, char *argv[])
 
     int is_waiting_for_dht_connection = 1;
 
-    uint64_t last_LANdiscovery = 0;
+    uint64_t last_lan_discovery = 0;
     const Broadcast_Info *broadcast = lan_discovery_init(ns);
 
     while (1) {
@@ -239,13 +241,13 @@ int main(int argc, char *argv[])
 
         do_dht(dht);
 
-        if (mono_time_is_timeout(mono_time, last_LANdiscovery, is_waiting_for_dht_connection ? 5 : LAN_DISCOVERY_INTERVAL)) {
+        if (mono_time_is_timeout(mono_time, last_lan_discovery, is_waiting_for_dht_connection ? 5 : LAN_DISCOVERY_INTERVAL)) {
             lan_discovery_send(dht_get_net(dht), broadcast, dht_get_self_public_key(dht), net_htons(PORT));
-            last_LANdiscovery = mono_time_get(mono_time);
+            last_lan_discovery = mono_time_get(mono_time);
         }
 
 #ifdef TCP_RELAY_ENABLED
-        do_TCP_server(tcp_s, mono_time);
+        do_tcp_server(tcp_s, mono_time);
 #endif
         networking_poll(dht_get_net(dht), nullptr);
 

external/toxcore/c-toxcore/other/analysis/run-clang-tidy

@@ -2,65 +2,120 @@
 
 CHECKS="*"
 
+# We don't use memcpy_s.
+CHECKS="$CHECKS,-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling"
+
 # __attribute__((nonnull)) causes this warning on defensive null checks.
 CHECKS="$CHECKS,-clang-diagnostic-pointer-bool-conversion"
 CHECKS="$CHECKS,-clang-diagnostic-tautological-pointer-compare"
 
-# TODO(iphydf): We might want some of these. For the ones we don't want, add a
-# comment explaining why not.
-CHECKS="$CHECKS,-altera-unroll-loops"
-CHECKS="$CHECKS,-android-cloexec-accept"
-CHECKS="$CHECKS,-android-cloexec-fopen"
-CHECKS="$CHECKS,-bugprone-not-null-terminated-result"
-CHECKS="$CHECKS,-bugprone-reserved-identifier"
-CHECKS="$CHECKS,-bugprone-sizeof-expression"
-CHECKS="$CHECKS,-cert-dcl37-c"
-CHECKS="$CHECKS,-cert-dcl51-cpp"
-CHECKS="$CHECKS,-clang-analyzer-optin.performance.Padding"
-CHECKS="$CHECKS,-cppcoreguidelines-avoid-magic-numbers"
+# Conflicts with "Variable is assigned a value that is never used."
+# [unreadVariable]
 CHECKS="$CHECKS,-cppcoreguidelines-init-variables"
-CHECKS="$CHECKS,-hicpp-multiway-paths-covered"
-CHECKS="$CHECKS,-hicpp-signed-bitwise"
-CHECKS="$CHECKS,-llvm-else-after-return"
-CHECKS="$CHECKS,-llvmlibc-restrict-system-libc-headers"
-CHECKS="$CHECKS,-misc-redundant-expression"
-CHECKS="$CHECKS,-misc-unused-parameters"
-CHECKS="$CHECKS,-readability-else-after-return"
-CHECKS="$CHECKS,-readability-function-cognitive-complexity"
-CHECKS="$CHECKS,-readability-inconsistent-declaration-parameter-name"
-CHECKS="$CHECKS,-readability-magic-numbers"
-CHECKS="$CHECKS,-readability-redundant-control-flow"
 
-# TODO(iphydf): Maybe fix these?
+# Short variable names are used quite a lot, and we don't consider them a
+# readability issue.
+CHECKS="$CHECKS,-readability-identifier-length"
+
+# Altera checks are for GPUs (OpenCL). Our code doesn't run on GPUs.
 CHECKS="$CHECKS,-altera-id-dependent-backward-branch"
 CHECKS="$CHECKS,-altera-struct-pack-align"
+CHECKS="$CHECKS,-altera-unroll-loops"
+
+# We target systems other than Android, so we don't want to use non-standard
+# functions from the Android libc.
+CHECKS="$CHECKS,-android-cloexec-accept"
+CHECKS="$CHECKS,-android-cloexec-fopen"
+
+# This catches all the feature test macros (_POSIX_SOURCE etc.).
+CHECKS="$CHECKS,-bugprone-reserved-identifier"
+CHECKS="$CHECKS,-cert-dcl37-c"
+CHECKS="$CHECKS,-cert-dcl51-cpp"
+
+# Too restrictive. This makes sense if the branch clone is very large, but not
+# if it's a single line. It can make the code less readable.
 CHECKS="$CHECKS,-bugprone-branch-clone"
+
+# We intentionally send some not null-terminated strings in tests and use it for
+# the toxencryptsave magic number.
+CHECKS="$CHECKS,-bugprone-not-null-terminated-result"
+
+# We don't want default labels in enum switches.
+CHECKS="$CHECKS,-hicpp-multiway-paths-covered"
+
+# This can make readability quite a bit worse when the 2 cases look very
+# similar.
+CHECKS="$CHECKS,-llvm-else-after-return"
+CHECKS="$CHECKS,-readability-else-after-return"
+
+# We need 'return;' in empty functions because cimple won't allow empty
+# functions otherwise.
+CHECKS="$CHECKS,-readability-redundant-control-flow"
+
+# These are incredibly annoying, because things like
+#   uint16_t a = 0, b = 1, c = a > b ? a : b;
+#                                      ^
+# Trip the checker, which is true, because of integer promotion, but also not
+# very helpful as a diagnostic.
+CHECKS="$CHECKS,-bugprone-narrowing-conversions"
+CHECKS="$CHECKS,-cppcoreguidelines-narrowing-conversions"
+
+# Mistakenly thinks that
+#   const int a = 0, b = 1;
+#   assert(a < b);
+# is a constant expression in C (it is in C++ though, which is probably why it's
+# mistaken), suggesting to replace 'assert()' with 'static_assert()' in cases
+# where that won't work.
+#
+# There are ways to make 'static_assert()' work, but they are rather annoying --
+# they are somewhat ugly, hurting the readability, and some are error-prone:
+#
+# - Turning 'a' and 'b' into enum constants would make it work, but this falls
+#   apart if the enum types are compared against non-enums down the line
+#     error: enumerated and non-enumerated type in conditional expression [-Werror=extra]
+#
+# - Turning 'a' and 'b' into pre-processor macros is the only option left, but
+#   #defines and #undefs in the middle of a function hurt the readability and
+#   are less idiomatic than simply using 'const int'.
+CHECKS="$CHECKS,-cert-dcl03-c"
+CHECKS="$CHECKS,-hicpp-static-assert"
+CHECKS="$CHECKS,-misc-static-assert"
+
+# TODO(iphydf): We might want some of these. For the ones we don't want, add a
+# comment explaining why not.
+CHECKS="$CHECKS,-clang-analyzer-optin.performance.Padding"
+CHECKS="$CHECKS,-hicpp-signed-bitwise"
+CHECKS="$CHECKS,-misc-unused-parameters"
+CHECKS="$CHECKS,-readability-function-cognitive-complexity"
+
+# TODO(iphydf): Maybe fix these?
 CHECKS="$CHECKS,-bugprone-easily-swappable-parameters"
 CHECKS="$CHECKS,-bugprone-implicit-widening-of-multiplication-result"
 CHECKS="$CHECKS,-bugprone-integer-division"
-CHECKS="$CHECKS,-bugprone-narrowing-conversions"
-CHECKS="$CHECKS,-clang-analyzer-core.NonNullParamChecker"
 CHECKS="$CHECKS,-clang-analyzer-core.NullDereference"
-CHECKS="$CHECKS,-clang-analyzer-optin.portability.UnixAPI"
-CHECKS="$CHECKS,-clang-analyzer-unix.Malloc"
 CHECKS="$CHECKS,-clang-analyzer-valist.Uninitialized"
 CHECKS="$CHECKS,-concurrency-mt-unsafe"
 CHECKS="$CHECKS,-cppcoreguidelines-avoid-non-const-global-variables"
-CHECKS="$CHECKS,-cppcoreguidelines-narrowing-conversions"
-CHECKS="$CHECKS,-google-readability-casting"
 CHECKS="$CHECKS,-misc-no-recursion"
 
+# TODO(iphydf): Probably fix these.
+CHECKS="$CHECKS,-cert-err33-c"
+CHECKS="$CHECKS,-cppcoreguidelines-avoid-magic-numbers"
+CHECKS="$CHECKS,-google-readability-casting"
+CHECKS="$CHECKS,-modernize-macro-to-enum"
+CHECKS="$CHECKS,-readability-magic-numbers"
+
+# TODO(iphydf): These two trip on list.c. Investigate why.
+CHECKS="$CHECKS,-clang-analyzer-core.NonNullParamChecker"
+CHECKS="$CHECKS,-clang-analyzer-unix.Malloc"
+
 ERRORS="*"
 
 # TODO(iphydf): Fix these.
 ERRORS="$ERRORS,-bugprone-macro-parentheses"
-ERRORS="$ERRORS,-bugprone-posix-return"
-ERRORS="$ERRORS,-bugprone-signed-char-misuse"
 ERRORS="$ERRORS,-cert-err34-c"
 ERRORS="$ERRORS,-cert-str34-c"
-ERRORS="$ERRORS,-hicpp-uppercase-literal-suffix"
 ERRORS="$ERRORS,-readability-suspicious-call-argument"
-ERRORS="$ERRORS,-readability-uppercase-literal-suffix"
 
 set -eux
 
@@ -70,7 +125,7 @@ run() {
   for i in "${!EXTRA_ARGS[@]}"; do
     EXTRA_ARGS[$i]="--extra-arg=${EXTRA_ARGS[$i]}"
   done
-  clang-tidy-12 \
+  clang-tidy-14 \
     -p=_build \
     --extra-arg=-DMIN_LOGGER_LEVEL=LOGGER_LEVEL_TRACE \
     "${EXTRA_ARGS[@]}" \
@@ -84,4 +139,6 @@ run() {
     toxencryptsave/*.c
 }
 
+cmake . -B_build -GNinja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+
 . other/analysis/variants.sh

external/toxcore/c-toxcore/other/bootstrap_daemon/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary")
 
-package(features = ["layering_check"])
-
 cc_binary(
     name = "bootstrap_daemon",
     srcs = glob([

external/toxcore/c-toxcore/other/bootstrap_daemon/docker/Dockerfile

@@ -1,6 +1,6 @@
 ###########################################################
 # Builder image: we compile the code here (static build)
-FROM alpine:3.15.0 AS build
+FROM alpine:3.18.5 AS build
 
 RUN ["apk", "--no-cache", "add",\
  "build-base",\
@@ -62,7 +62,7 @@ RUN ["other/bootstrap_daemon/docker/get-nodes.py", "other/bootstrap_daemon/tox-b
 
 ###########################################################
 # Final image build: this is what runs the bootstrap node
-FROM debian:bullseye-slim
+FROM debian:bookworm-slim
 
 COPY --from=build /usr/local/bin/tox-bootstrapd /usr/local/bin/
 COPY --from=build /src/c-toxcore/other/bootstrap_daemon/tox-bootstrapd.conf /etc/tox-bootstrapd.conf

external/toxcore/c-toxcore/other/bootstrap_daemon/docker/tox-bootstrapd.sha256

@@ -1 +1 @@
-4f5b47978dc26aed78719526f862a44693f821db12f5ff6d70b338d67fb6f784  /usr/local/bin/tox-bootstrapd
+5aac1df4d6c1de289e8e9f646d06099c84fd4d9b80d19f45e3254eec3ece2bff  /usr/local/bin/tox-bootstrapd

external/toxcore/c-toxcore/other/bootstrap_daemon/docker/update-sha256

@@ -3,7 +3,7 @@
 set -eux
 
 docker_build() {
-  docker build -f other/bootstrap_daemon/docker/Dockerfile -t toxchat/bootstrap-node .
+  DOCKER_BUILDKIT=1 docker build --progress=plain -f other/bootstrap_daemon/docker/Dockerfile -t toxchat/bootstrap-node .
 }
 
 # Run Docker build once. If it succeeds, we're good.
@@ -12,12 +12,11 @@ if docker_build; then
 fi
 
 # We're not good. Run it again, but now capture the output.
-OUTPUT=$(docker_build || true 2>&1)
+OUTPUT=$(docker_build 2>&1 || true)
 
 if echo "$OUTPUT" | grep '/usr/local/bin/tox-bootstrapd: FAILED'; then
   # This is a checksum warning, so we need to update it.
-  IMAGE=$(echo "$OUTPUT" | grep '^ ---> [0-9a-f]*$' | grep -o '[0-9a-f]*$' | tail -n1)
-  docker run --rm "$IMAGE" sha256sum /usr/local/bin/tox-bootstrapd >other/bootstrap_daemon/docker/tox-bootstrapd.sha256
+  echo "$OUTPUT" | grep -Eo '[0-9a-f]{64}  /usr/local/bin/tox-bootstrapd' | tail -n1 >other/bootstrap_daemon/docker/tox-bootstrapd.sha256
 fi
 
 # Run once last time to complete the build.

external/toxcore/c-toxcore/other/bootstrap_daemon/src/config.c

@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-3.0-or-later
- * Copyright © 2016-2018 The TokTok team.
+ * Copyright © 2016-2023 The TokTok team.
  * Copyright © 2014-2016 Tox project.
  */
 
@@ -29,7 +29,7 @@
  */
 static void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_ports, int *tcp_relay_port_count)
 {
-    const char *NAME_TCP_RELAY_PORTS = "tcp_relay_ports";
+    const char *const NAME_TCP_RELAY_PORTS = "tcp_relay_ports";
 
     *tcp_relay_port_count = 0;
 
@@ -39,22 +39,28 @@ static void parse_tcp_relay_ports_config(config_t *cfg, uint16_t **tcp_relay_por
         log_write(LOG_LEVEL_WARNING, "No '%s' setting in the configuration file.\n", NAME_TCP_RELAY_PORTS);
         log_write(LOG_LEVEL_WARNING, "Using default '%s':\n", NAME_TCP_RELAY_PORTS);
 
-        uint16_t default_ports[DEFAULT_TCP_RELAY_PORTS_COUNT] = {DEFAULT_TCP_RELAY_PORTS};
+        uint16_t default_ports[] = {DEFAULT_TCP_RELAY_PORTS};
 
-        for (int i = 0; i < DEFAULT_TCP_RELAY_PORTS_COUNT; ++i) {
-            log_write(LOG_LEVEL_INFO, "Port #%d: %u\n", i, default_ports[i]);
+        // Check to avoid calling malloc(0) later on
+        // NOLINTNEXTLINE, clang-tidy: error: suspicious comparison of 'sizeof(expr)' to a constant [bugprone-sizeof-expression,-warnings-as-errors]
+        static_assert(sizeof(default_ports) > 0, "At least one default TCP relay port should be provided");
+
+        const size_t default_ports_count = sizeof(default_ports)/sizeof(*default_ports);
+
+        for (size_t i = 0; i < default_ports_count; ++i) {
+            log_write(LOG_LEVEL_INFO, "Port #%zu: %u\n", i, default_ports[i]);
         }
 
         // similar procedure to the one of reading config file below
-        *tcp_relay_ports = (uint16_t *)malloc(DEFAULT_TCP_RELAY_PORTS_COUNT * sizeof(uint16_t));
+        *tcp_relay_ports = (uint16_t *)malloc(default_ports_count * sizeof(uint16_t));
 
-        for (int i = 0; i < DEFAULT_TCP_RELAY_PORTS_COUNT; ++i) {
+        for (size_t i = 0; i < default_ports_count; ++i) {
 
             (*tcp_relay_ports)[*tcp_relay_port_count] = default_ports[i];
 
             if ((*tcp_relay_ports)[*tcp_relay_port_count] < MIN_ALLOWED_PORT
                     || (*tcp_relay_ports)[*tcp_relay_port_count] > MAX_ALLOWED_PORT) {
-                log_write(LOG_LEVEL_WARNING, "Port #%d: Invalid port: %u, should be in [%d, %d]. Skipping.\n", i,
+                log_write(LOG_LEVEL_WARNING, "Port #%zu: Invalid port: %u, should be in [%d, %d]. Skipping.\n", i,
                           (*tcp_relay_ports)[*tcp_relay_port_count], MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
                 continue;
             }
@@ -129,15 +135,15 @@ int get_general_config(const char *cfg_file_path, char **pid_file_path, char **k
 {
     config_t cfg;
 
-    const char *NAME_PORT                 = "port";
-    const char *NAME_PID_FILE_PATH        = "pid_file_path";
-    const char *NAME_KEYS_FILE_PATH       = "keys_file_path";
-    const char *NAME_ENABLE_IPV6          = "enable_ipv6";
-    const char *NAME_ENABLE_IPV4_FALLBACK = "enable_ipv4_fallback";
-    const char *NAME_ENABLE_LAN_DISCOVERY = "enable_lan_discovery";
-    const char *NAME_ENABLE_TCP_RELAY     = "enable_tcp_relay";
-    const char *NAME_ENABLE_MOTD          = "enable_motd";
-    const char *NAME_MOTD                 = "motd";
+    const char *const NAME_PORT                 = "port";
+    const char *const NAME_PID_FILE_PATH        = "pid_file_path";
+    const char *const NAME_KEYS_FILE_PATH       = "keys_file_path";
+    const char *const NAME_ENABLE_IPV6          = "enable_ipv6";
+    const char *const NAME_ENABLE_IPV4_FALLBACK = "enable_ipv4_fallback";
+    const char *const NAME_ENABLE_LAN_DISCOVERY = "enable_lan_discovery";
+    const char *const NAME_ENABLE_TCP_RELAY     = "enable_tcp_relay";
+    const char *const NAME_ENABLE_MOTD          = "enable_motd";
+    const char *const NAME_MOTD                 = "motd";
 
     config_init(&cfg);
 
@@ -307,11 +313,11 @@ static uint8_t *bootstrap_hex_string_to_bin(const char *hex_string)
 
 int bootstrap_from_config(const char *cfg_file_path, DHT *dht, int enable_ipv6)
 {
-    const char *NAME_BOOTSTRAP_NODES = "bootstrap_nodes";
+    const char *const NAME_BOOTSTRAP_NODES = "bootstrap_nodes";
 
-    const char *NAME_PUBLIC_KEY = "public_key";
-    const char *NAME_PORT       = "port";
-    const char *NAME_ADDRESS    = "address";
+    const char *const NAME_PUBLIC_KEY = "public_key";
+    const char *const NAME_PORT       = "port";
+    const char *const NAME_ADDRESS    = "address";
 
     config_t cfg;
 

external/toxcore/c-toxcore/other/bootstrap_daemon/src/config_defaults.h

@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-3.0-or-later
- * Copyright © 2016-2018 The TokTok team.
+ * Copyright © 2016-2023 The TokTok team.
  * Copyright © 2014-2016 Tox project.
  */
 
@@ -19,8 +19,7 @@
 #define DEFAULT_ENABLE_IPV4_FALLBACK  1 // 1 - true, 0 - false
 #define DEFAULT_ENABLE_LAN_DISCOVERY  1 // 1 - true, 0 - false
 #define DEFAULT_ENABLE_TCP_RELAY      1 // 1 - true, 0 - false
-#define DEFAULT_TCP_RELAY_PORTS       443, 3389, 33445 // comma-separated list of ports. make sure to adjust DEFAULT_TCP_RELAY_PORTS_COUNT accordingly
-#define DEFAULT_TCP_RELAY_PORTS_COUNT 3
+#define DEFAULT_TCP_RELAY_PORTS       443, 3389, 33445 // comma-separated list of ports
 #define DEFAULT_ENABLE_MOTD           1 // 1 - true, 0 - false
 #define DEFAULT_MOTD                  DAEMON_NAME
 

external/toxcore/c-toxcore/other/bootstrap_daemon/src/tox-bootstrapd.c

@@ -61,10 +61,9 @@ static int manage_keys(DHT *dht, char *keys_file_path)
 {
     enum { KEYS_SIZE = CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE };
     uint8_t keys[KEYS_SIZE];
-    FILE *keys_file;
 
     // Check if file exits, proceed to open and load keys
-    keys_file = fopen(keys_file_path, "rb");
+    FILE *keys_file = fopen(keys_file_path, "rb");
 
     if (keys_file != nullptr) {
         const size_t read_size = fread(keys, sizeof(uint8_t), KEYS_SIZE, keys_file);
@@ -120,9 +119,9 @@ static void print_public_key(const uint8_t *public_key)
 static void daemonize(LOG_BACKEND log_backend, char *pid_file_path)
 {
     // Check if the PID file exists
-    FILE *pid_file;
+    FILE *pid_file = fopen(pid_file_path, "r");
 
-    if ((pid_file = fopen(pid_file_path, "r"))) {
+    if (pid_file != nullptr) {
         log_write(LOG_LEVEL_WARNING, "Another instance of the daemon is already running, PID file %s exists.\n", pid_file_path);
         fclose(pid_file);
     }
@@ -175,38 +174,29 @@ static void daemonize(LOG_BACKEND log_backend, char *pid_file_path)
 
 // Logs toxcore logger message using our logger facility
 
+static LOG_LEVEL logger_level_to_log_level(Logger_Level level)
+{
+    switch (level) {
+        case LOGGER_LEVEL_TRACE:
+        case LOGGER_LEVEL_DEBUG:
+        case LOGGER_LEVEL_INFO:
+            return LOG_LEVEL_INFO;
+
+        case LOGGER_LEVEL_WARNING:
+            return LOG_LEVEL_WARNING;
+
+        case LOGGER_LEVEL_ERROR:
+            return LOG_LEVEL_ERROR;
+
+        default:
+            return LOG_LEVEL_INFO;
+    }
+}
+
 static void toxcore_logger_callback(void *context, Logger_Level level, const char *file, int line,
                                     const char *func, const char *message, void *userdata)
 {
-    LOG_LEVEL log_level;
-
-    switch (level) {
-        case LOGGER_LEVEL_TRACE:
-            log_level = LOG_LEVEL_INFO;
-            break;
-
-        case LOGGER_LEVEL_DEBUG:
-            log_level = LOG_LEVEL_INFO;
-            break;
-
-        case LOGGER_LEVEL_INFO:
-            log_level = LOG_LEVEL_INFO;
-            break;
-
-        case LOGGER_LEVEL_WARNING:
-            log_level = LOG_LEVEL_WARNING;
-            break;
-
-        case LOGGER_LEVEL_ERROR:
-            log_level = LOG_LEVEL_ERROR;
-            break;
-
-        default:
-            log_level = LOG_LEVEL_INFO;
-            break;
-    }
-
-    log_write(log_level, "%s:%d(%s) %s\n", file, line, func, message);
+    log_write(logger_level_to_log_level(level), "%s:%d(%s) %s\n", file, line, func, message);
 }
 
 static volatile sig_atomic_t caught_signal = 0;
@@ -220,11 +210,10 @@ int main(int argc, char *argv[])
 {
     umask(077);
     char *cfg_file_path = nullptr;
-    LOG_BACKEND log_backend;
-    bool run_in_foreground;
+    bool run_in_foreground = false;
 
     // choose backend for printing command line argument parsing output based on whether the daemon is being run from a terminal
-    log_backend = isatty(STDOUT_FILENO) ? LOG_BACKEND_STDOUT : LOG_BACKEND_SYSLOG;
+    LOG_BACKEND log_backend = isatty(STDOUT_FILENO) ? LOG_BACKEND_STDOUT : LOG_BACKEND_SYSLOG;
 
     log_open(log_backend);
     handle_command_line_arguments(argc, argv, &cfg_file_path, &log_backend, &run_in_foreground);
@@ -236,14 +225,14 @@ int main(int argc, char *argv[])
 
     char *pid_file_path = nullptr;
     char *keys_file_path = nullptr;
-    int start_port;
-    int enable_ipv6;
-    int enable_ipv4_fallback;
-    int enable_lan_discovery;
-    int enable_tcp_relay;
+    int start_port = 0;
+    int enable_ipv6 = 0;
+    int enable_ipv4_fallback = 0;
+    int enable_lan_discovery = 0;
+    int enable_tcp_relay = 0;
     uint16_t *tcp_relay_ports = nullptr;
-    int tcp_relay_port_count;
-    int enable_motd;
+    int tcp_relay_port_count = 0;
+    int enable_motd = 0;
     char *motd = nullptr;
 
     if (get_general_config(cfg_file_path, &pid_file_path, &keys_file_path, &start_port, &enable_ipv6, &enable_ipv4_fallback,
@@ -275,20 +264,22 @@ int main(int argc, char *argv[])
 
     Logger *logger = logger_new();
 
-    if (MIN_LOGGER_LEVEL == LOGGER_LEVEL_TRACE || MIN_LOGGER_LEVEL == LOGGER_LEVEL_DEBUG) {
+    if (MIN_LOGGER_LEVEL <= LOGGER_LEVEL_DEBUG) {
         logger_callback_log(logger, toxcore_logger_callback, nullptr, nullptr);
     }
 
     const uint16_t end_port = start_port + (TOX_PORTRANGE_TO - TOX_PORTRANGE_FROM);
+    const Memory *mem = system_memory();
+    const Random *rng = system_random();
     const Network *ns = system_network();
-    Networking_Core *net = new_networking_ex(logger, ns, &ip, start_port, end_port, nullptr);
+    Networking_Core *net = new_networking_ex(logger, mem, ns, &ip, start_port, end_port, nullptr);
 
     if (net == nullptr) {
         if (enable_ipv6 && enable_ipv4_fallback) {
             log_write(LOG_LEVEL_WARNING, "Couldn't initialize IPv6 networking. Falling back to using IPv4.\n");
             enable_ipv6 = 0;
             ip_init(&ip, enable_ipv6);
-            net = new_networking_ex(logger, ns, &ip, start_port, end_port, nullptr);
+            net = new_networking_ex(logger, mem, ns, &ip, start_port, end_port, nullptr);
 
             if (net == nullptr) {
                 log_write(LOG_LEVEL_ERROR, "Couldn't fallback to IPv4. Exiting.\n");
@@ -308,7 +299,7 @@ int main(int argc, char *argv[])
         }
     }
 
-    Mono_Time *const mono_time = mono_time_new(nullptr, nullptr);
+    Mono_Time *const mono_time = mono_time_new(mem, nullptr, nullptr);
 
     if (mono_time == nullptr) {
         log_write(LOG_LEVEL_ERROR, "Couldn't initialize monotonic timer. Exiting.\n");
@@ -322,12 +313,11 @@ int main(int argc, char *argv[])
 
     mono_time_update(mono_time);
 
-    const Random *rng = system_random();
-    DHT *const dht = new_dht(logger, rng, ns, mono_time, net, true, enable_lan_discovery);
+    DHT *const dht = new_dht(logger, mem, rng, ns, mono_time, net, true, enable_lan_discovery);
 
     if (dht == nullptr) {
         log_write(LOG_LEVEL_ERROR, "Couldn't initialize Tox DHT instance. Exiting.\n");
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(motd);
@@ -341,7 +331,7 @@ int main(int argc, char *argv[])
     if (forwarding == nullptr) {
         log_write(LOG_LEVEL_ERROR, "Couldn't initialize forwarding. Exiting.\n");
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(motd);
@@ -350,13 +340,13 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    Announcements *announce = new_announcements(logger, rng, mono_time, forwarding);
+    Announcements *announce = new_announcements(logger, mem, rng, mono_time, forwarding);
 
     if (announce == nullptr) {
         log_write(LOG_LEVEL_ERROR, "Couldn't initialize DHT announcements. Exiting.\n");
         kill_forwarding(forwarding);
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(motd);
@@ -372,7 +362,7 @@ int main(int argc, char *argv[])
         kill_announcements(announce);
         kill_forwarding(forwarding);
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(motd);
@@ -381,14 +371,15 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    Onion *onion = new_onion(logger, mono_time, rng, dht);
+    Onion *onion = new_onion(logger, mem, mono_time, rng, dht);
 
     if (!onion) {
         log_write(LOG_LEVEL_ERROR, "Couldn't initialize Tox Onion. Exiting.\n");
+        kill_gca(group_announce);
         kill_announcements(announce);
         kill_forwarding(forwarding);
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(motd);
@@ -397,7 +388,7 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    Onion_Announce *onion_a = new_onion_announce(logger, rng, mono_time, dht);
+    Onion_Announce *onion_a = new_onion_announce(logger, mem, rng, mono_time, dht);
 
     if (!onion_a) {
         log_write(LOG_LEVEL_ERROR, "Couldn't initialize Tox Onion Announce. Exiting.\n");
@@ -406,7 +397,7 @@ int main(int argc, char *argv[])
         kill_announcements(announce);
         kill_forwarding(forwarding);
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(motd);
@@ -429,7 +420,7 @@ int main(int argc, char *argv[])
             kill_announcements(announce);
             kill_forwarding(forwarding);
             kill_dht(dht);
-            mono_time_free(mono_time);
+            mono_time_free(mem, mono_time);
             kill_networking(net);
             logger_kill(logger);
             free(motd);
@@ -450,7 +441,7 @@ int main(int argc, char *argv[])
         kill_announcements(announce);
         kill_forwarding(forwarding);
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         free(tcp_relay_ports);
@@ -464,19 +455,20 @@ int main(int argc, char *argv[])
         if (tcp_relay_port_count == 0) {
             log_write(LOG_LEVEL_ERROR, "No TCP relay ports read. Exiting.\n");
             kill_onion_announce(onion_a);
-	        kill_gca(group_announce);
+            kill_gca(group_announce);
             kill_announcements(announce);
             kill_forwarding(forwarding);
             kill_onion(onion);
             kill_dht(dht);
-            mono_time_free(mono_time);
+            mono_time_free(mem, mono_time);
             kill_networking(net);
             logger_kill(logger);
             free(tcp_relay_ports);
             return 1;
         }
 
-        tcp_server = new_TCP_server(logger, rng, ns, enable_ipv6, tcp_relay_port_count, tcp_relay_ports,
+        tcp_server = new_tcp_server(logger, mem, rng, ns, enable_ipv6,
+                                    tcp_relay_port_count, tcp_relay_ports,
                                     dht_get_self_secret_key(dht), onion, forwarding);
 
         free(tcp_relay_ports);
@@ -515,7 +507,7 @@ int main(int argc, char *argv[])
             kill_announcements(announce);
             kill_forwarding(forwarding);
             kill_dht(dht);
-            mono_time_free(mono_time);
+            mono_time_free(mem, mono_time);
             kill_networking(net);
             logger_kill(logger);
             return 1;
@@ -526,14 +518,14 @@ int main(int argc, char *argv[])
         log_write(LOG_LEVEL_INFO, "List of bootstrap nodes read successfully.\n");
     } else {
         log_write(LOG_LEVEL_ERROR, "Couldn't read list of bootstrap nodes in %s. Exiting.\n", cfg_file_path);
-        kill_TCP_server(tcp_server);
+        kill_tcp_server(tcp_server);
         kill_onion_announce(onion_a);
         kill_gca(group_announce);
         kill_onion(onion);
         kill_announcements(announce);
         kill_forwarding(forwarding);
         kill_dht(dht);
-        mono_time_free(mono_time);
+        mono_time_free(mem, mono_time);
         kill_networking(net);
         logger_kill(logger);
         return 1;
@@ -541,7 +533,7 @@ int main(int argc, char *argv[])
 
     print_public_key(dht_get_self_public_key(dht));
 
-    uint64_t last_LANdiscovery = 0;
+    uint64_t last_lan_discovery = 0;
     const uint16_t net_htons_port = net_htons(start_port);
 
     int waiting_for_dht_connection = 1;
@@ -576,13 +568,13 @@ int main(int argc, char *argv[])
 
         do_dht(dht);
 
-        if (enable_lan_discovery && mono_time_is_timeout(mono_time, last_LANdiscovery, LAN_DISCOVERY_INTERVAL)) {
+        if (enable_lan_discovery && mono_time_is_timeout(mono_time, last_lan_discovery, LAN_DISCOVERY_INTERVAL)) {
             lan_discovery_send(dht_get_net(dht), broadcast, dht_get_self_public_key(dht), net_htons_port);
-            last_LANdiscovery = mono_time_get(mono_time);
+            last_lan_discovery = mono_time_get(mono_time);
         }
 
         if (enable_tcp_relay) {
-            do_TCP_server(tcp_server, mono_time);
+            do_tcp_server(tcp_server, mono_time);
         }
 
         networking_poll(dht_get_net(dht), nullptr);
@@ -609,14 +601,14 @@ int main(int argc, char *argv[])
     }
 
     lan_discovery_kill(broadcast);
-    kill_TCP_server(tcp_server);
+    kill_tcp_server(tcp_server);
     kill_onion_announce(onion_a);
     kill_gca(group_announce);
     kill_onion(onion);
     kill_announcements(announce);
     kill_forwarding(forwarding);
     kill_dht(dht);
-    mono_time_free(mono_time);
+    mono_time_free(mem, mono_time);
     kill_networking(net);
     logger_kill(logger);
 

external/toxcore/c-toxcore/other/bootstrap_daemon/websocket/websockify/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
 
-package(features = ["-layering_check"])
-
 go_library(
     name = "go_default_library",
     srcs = ["websockify.go"],

external/toxcore/c-toxcore/other/docker/alpine-s390x/Dockerfile

@@ -0,0 +1,6 @@
+FROM toxchat/alpine-s390x:latest
+
+WORKDIR /work/c-toxcore
+COPY . /work/c-toxcore/
+
+RUN [".github/scripts/cmake-alpine-s390x"]

external/toxcore/c-toxcore/other/docker/alpine-s390x/run

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -eux
+BUILD=alpine-s390x
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/docker/autotools/run

@@ -1,3 +1,5 @@
 #!/bin/sh
 
-docker build -t toxchat/c-toxcore:autotools -f other/docker/autotools/Dockerfile .
+set -eux
+BUILD=autotools
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/docker/cimplefmt/Dockerfile

@@ -1,5 +1,5 @@
 FROM toxchat/haskell:hs-cimple AS cimple
-FROM ubuntu:20.04
+FROM ubuntu:22.04
 
 COPY --from=cimple /bin/cimplefmt /bin/
 WORKDIR /work

external/toxcore/c-toxcore/other/docker/cimplefmt/run

@@ -5,4 +5,4 @@ if [ "$1" = "-u" ]; then
   docker pull toxchat/haskell:hs-cimple
   docker build -t toxchat/cimplefmt -f other/docker/cimplefmt/Dockerfile .
 fi
-docker run --rm -v "$PWD:/work" toxchat/cimplefmt "$@"
+docker run --name toxcore-cimplefmt --rm -v "$PWD:/work" toxchat/cimplefmt "$@"

external/toxcore/c-toxcore/other/docker/circleci/run

@@ -3,4 +3,4 @@
 SANITIZER="${1:-asan}"
 
 docker build -t toxchat/c-toxcore:circleci other/docker/circleci
-docker run --rm -it -v "$PWD:/c-toxcore" toxchat/c-toxcore:circleci "$SANITIZER"
+docker run --name toxcore-circleci --rm -it -v "$PWD:/c-toxcore" toxchat/c-toxcore:circleci "$SANITIZER"

external/toxcore/c-toxcore/other/docker/compcert/Dockerfile

@@ -0,0 +1,30 @@
+FROM toxchat/compcert:latest
+
+WORKDIR /work
+COPY auto_tests/ /work/auto_tests/
+COPY testing/ /work/testing/
+COPY toxav/ /work/toxav/
+COPY toxcore/ /work/toxcore/
+COPY toxencryptsave/ /work/toxencryptsave/
+COPY third_party/ /work/third_party/
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+RUN ccomp \
+ -o send_message_test \
+ -Wall -Werror \
+ -Wno-c11-extensions \
+ -Wno-unknown-pragmas \
+ -Wno-unused-variable \
+ -fstruct-passing -fno-unprototyped -g \
+ auto_tests/auto_test_support.c \
+ auto_tests/send_message_test.c \
+ testing/misc_tools.c \
+ toxav/*.c \
+ toxcore/*.c \
+ toxcore/*/*.c \
+ toxencryptsave/*.c \
+ third_party/cmp/*.c \
+ -D__COMPCERT__ -DDISABLE_VLA -Dinline= \
+ -lpthread $(pkg-config --cflags --libs libsodium opus vpx) \
+ && ./send_message_test | grep 'tox clients connected'

external/toxcore/c-toxcore/other/docker/compcert/run

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -eux
+BUILD=compcert
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/docker/coverage/Dockerfile

@@ -1,5 +1,5 @@
 FROM toxchat/c-toxcore:sources AS src
-FROM ubuntu:20.04 AS build
+FROM ubuntu:22.04 AS build
 
 RUN apt-get update && \
  DEBIAN_FRONTEND="noninteractive" apt-get install -y --no-install-recommends \
@@ -31,8 +31,8 @@ SHELL ["/bin/bash", "-c"]
 WORKDIR /work
 COPY --from=src /src/ /work/
 RUN source .github/scripts/flags-coverage.sh \
- && go get github.com/things-go/go-socks5 \
- && go build other/proxy/proxy_server.go \
+ && go version \
+ && (cd other/proxy && go get github.com/things-go/go-socks5 && go build proxy_server.go) \
  && cmake -B_build -H. -GNinja \
  -DCMAKE_C_FLAGS="$C_FLAGS" \
  -DCMAKE_CXX_FLAGS="$CXX_FLAGS" \
@@ -46,6 +46,7 @@ RUN source .github/scripts/flags-coverage.sh \
  -DAUTOTEST=ON \
  -DPROXY_TEST=ON \
  -DUSE_IPV6=OFF \
+ -DTEST_TIMEOUT_SECONDS=30 \
  && cmake --build _build --parallel 8 --target install
 
 WORKDIR /work/_build

external/toxcore/c-toxcore/other/docker/coverage/run

@@ -4,4 +4,4 @@ set -eux
 
 docker build -t toxchat/c-toxcore:sources -f other/docker/sources/Dockerfile .
 docker build -t toxchat/c-toxcore:coverage other/docker/coverage
-docker run --rm -it -p "28192:80" toxchat/c-toxcore:coverage
+docker run --name toxcore-coverage --rm -it -p "28192:80" toxchat/c-toxcore:coverage

external/toxcore/c-toxcore/other/docker/doxygen/run

@@ -3,4 +3,4 @@
 set -eux
 
 docker build -t toxchat/c-toxcore:docs -f other/docker/doxygen/Dockerfile .
-docker run --rm -it -p "28192:80" toxchat/c-toxcore:docs
+docker run --name toxcore-docs --rm -it -p "28192:80" toxchat/c-toxcore:docs

external/toxcore/c-toxcore/other/docker/freebsd/Dockerfile

@@ -0,0 +1,6 @@
+FROM toxchat/freebsd:latest
+
+WORKDIR /work/c-toxcore
+COPY . /work/c-toxcore/
+
+RUN [".github/scripts/cmake-freebsd"]

external/toxcore/c-toxcore/other/docker/freebsd/run

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -eux
+BUILD=freebsd
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/docker/misra/run

@@ -1,3 +1,5 @@
 #!/bin/sh
 
-docker build -f other/docker/misra/Dockerfile .
+set -eux
+BUILD=misra
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/docker/perf/run

@@ -3,7 +3,7 @@
 set -eux
 
 docker build -t toxchat/c-toxcore:perf -f other/docker/perf/Dockerfile .
-docker run --privileged --rm -it \
+docker run --name toxcore-perf --privileged --rm -it \
   -v "$PWD:/work/c-toxcore" \
   toxchat/c-toxcore:perf \
   "$@"

external/toxcore/c-toxcore/other/docker/tcc/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:20.04
+FROM ubuntu:22.04
 
 RUN apt-get update && \
  DEBIAN_FRONTEND="noninteractive" apt-get install -y --no-install-recommends \
@@ -17,6 +17,9 @@ COPY testing/ /work/testing/
 COPY toxav/ /work/toxav/
 COPY toxcore/ /work/toxcore/
 COPY toxencryptsave/ /work/toxencryptsave/
+COPY third_party/ /work/third_party/
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
 RUN tcc \
  -Dinline=static \
@@ -31,9 +34,9 @@ RUN tcc \
  toxcore/*/*.c \
  toxencryptsave/*.c \
  third_party/cmp/*.c \
- $(pkg-config --cflags --libs libsodium opus vpx)
+ $(pkg-config --cflags --libs libsodium opus vpx) \
+ && ./send_message_test | grep 'tox clients connected'
 
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 COPY other/make_single_file /work/other/
 RUN \
  other/make_single_file \
@@ -44,4 +47,5 @@ RUN \
    -o send_message_test \
    -Wall -Werror \
    -bench -g \
-   $(pkg-config --cflags --libs libsodium opus vpx)
+   $(pkg-config --cflags --libs libsodium opus vpx) \
+ && ./send_message_test | grep 'tox clients connected'

external/toxcore/c-toxcore/other/docker/tcc/run

@@ -1,5 +1,5 @@
 #!/bin/sh
 
 set -eux
-
-docker build -t toxchat/c-toxcore:tcc -f other/docker/tcc/Dockerfile .
+BUILD=tcc
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/docker/tokstyle/Dockerfile

@@ -1,5 +1,5 @@
 FROM toxchat/haskell:hs-tokstyle AS tokstyle
-FROM ubuntu:20.04
+FROM ubuntu:22.04
 
 RUN apt-get update && apt-get install --no-install-recommends -y \
  ca-certificates \

external/toxcore/c-toxcore/other/docker/tokstyle/run

@@ -1,3 +1,5 @@
 #!/bin/sh
 
-docker build -f other/docker/tokstyle/Dockerfile .
+set -eux
+BUILD=tokstyle
+docker build -t "toxchat/c-toxcore:$BUILD" -f "other/docker/$BUILD/Dockerfile" .

external/toxcore/c-toxcore/other/event_tooling/generate_event_c.cpp

@@ -306,7 +306,7 @@ void generate_event_impl(const std::string& event_name, std::vector<EventType> e
     f << "    Tox_Event_" << event_name << " *event, Bin_Unpack *bu)\n{\n";
     f << "    assert(event != nullptr);\n";
     if (event_types.size() > 1) {
-        f << "    if (!bin_unpack_array_fixed(bu, " << event_types.size() << ")) {\n        return false;\n    }\n\n";
+        f << "    if (!bin_unpack_array_fixed(bu, " << event_types.size() << ", nullptr)) {\n        return false;\n    }\n\n";
     }
 
     bool first = true;

external/toxcore/c-toxcore/other/fun/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary")
 
-package(features = ["layering_check"])
-
 #cc_binary(
 #    name = "cracker",
 #    testonly = 1,

external/toxcore/c-toxcore/other/fun/save-generator.c

@@ -73,10 +73,15 @@ static void print_information(Tox *tox)
     int length = snprintf(nospam_str, sizeof(nospam_str), "%08X", nospam);
     nospam_str[length] = '\0';
 
-    uint8_t *name = (uint8_t *)malloc(tox_self_get_name_size(tox) + 1);
-    assert(name != nullptr);
+    size_t name_size = tox_self_get_name_size(tox);
+    uint8_t *name = (uint8_t *)malloc(name_size + 1);
+
+    if (!name) {
+        return;
+    }
+
     tox_self_get_name(tox, name);
-    name[tox_self_get_name_size(tox)] = '\0';
+    name[name_size] = '\0';
 
     printf("INFORMATION\n");
     printf("----------------------------------\n");
@@ -86,6 +91,8 @@ static void print_information(Tox *tox)
     printf("Status message: %s.\n", GENERATED_STATUS_MESSAGE);
     printf("Number of friends: %zu.\n", tox_self_get_friend_list_size(tox));
     printf("----------------------------------\n");
+
+    free(name);
 }
 
 int main(int argc, char *argv[])

external/toxcore/c-toxcore/other/proxy/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
 
-package(features = ["layering_check"])
-
 go_library(
     name = "go_default_library",
     srcs = ["proxy_server.go"],

external/toxcore/c-toxcore/other/proxy/go.mod

@@ -1,5 +1,5 @@
 module github.com/TokTok/c-toxcore/other/proxy
 
-go 1.16
+go 1.18
 
-require github.com/things-go/go-socks5 v0.0.2
+require github.com/things-go/go-socks5 v0.0.3

external/toxcore/c-toxcore/other/proxy/go.sum

@@ -4,6 +4,8 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/things-go/go-socks5 v0.0.2 h1:dFi5iZ/LqgHRTQ6n3XlipTLDWHAQsejvJ300bH2VFWo=
 github.com/things-go/go-socks5 v0.0.2/go.mod h1:dhnDTBbIg31cbJdROP4/Zz6Iw7JPEpiMvOl2LdHSSjE=
+github.com/things-go/go-socks5 v0.0.3 h1:QtlIhkwDuLNCwW3wnt2uTjn1mQzpyjnwct2xdPuqroI=
+github.com/things-go/go-socks5 v0.0.3/go.mod h1:f8Zx+n8kfzyT90hXM767cP6sysAud93+t9rV90IgMcg=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

external/toxcore/c-toxcore/super_donators/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary")
 
-package(features = ["layering_check"])
-
 cc_binary(
     name = "grencez_tok5",
     srcs = ["grencez_tok5.c"],

external/toxcore/c-toxcore/testing/BUILD.bazel

@@ -1,7 +1,5 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
 
-package(features = ["layering_check"])
-
 CIMPLE_FILES = [
     "//c-toxcore/toxav:cimple_files",
     "//c-toxcore/toxcore:cimple_files",
@@ -15,9 +13,7 @@ sh_test(
     args = ["$(locations %s)" % f for f in CIMPLE_FILES] + [
         "-Wno-boolean-return",
         "-Wno-callback-names",
-        "-Wno-callgraph",
         "-Wno-enum-names",
-        "-Wno-type-check",
         "+RTS",
         "-N3",
         "-RTS",

external/toxcore/c-toxcore/testing/Messenger_test.c

@@ -92,7 +92,8 @@ int main(int argc, char *argv[])
         exit(0);
     }
 
-    Mono_Time *const mono_time = mono_time_new(nullptr, nullptr);
+    const Memory *mem = system_memory();
+    Mono_Time *const mono_time = mono_time_new(mem, nullptr, nullptr);
 
     if (mono_time == nullptr) {
         fputs("Failed to allocate monotonic timer datastructure\n", stderr);
@@ -102,7 +103,7 @@ int main(int argc, char *argv[])
     Messenger_Options options = {0};
     options.ipv6enabled = ipv6enabled;
     Messenger_Error err;
-    m = new_messenger(mono_time, system_random(), system_network(), &options, &err);
+    m = new_messenger(mono_time, mem, system_random(), system_network(), &options, &err);
 
     if (!m) {
         fprintf(stderr, "Failed to allocate messenger datastructure: %d\n", err);

external/toxcore/c-toxcore/testing/fuzzing/BUILD.bazel

@@ -2,8 +2,6 @@ load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
 load("@rules_fuzzing//fuzzing:cc_defs.bzl", "cc_fuzz_test")
 load("@rules_fuzzing//fuzzing/private:binary.bzl", "fuzzing_binary")  # buildifier: disable=bzl-visibility
 
-package(features = ["layering_check"])
-
 cc_library(
     name = "fuzz_support",
     srcs = [
@@ -28,6 +26,7 @@ cc_library(
 
 cc_fuzz_test(
     name = "bootstrap_fuzz_test",
+    size = "small",
     srcs = ["bootstrap_harness.cc"],
     copts = ["-UNDEBUG"],
     corpus = ["//tools/toktok-fuzzer/corpus:bootstrap_fuzzer"],
@@ -42,6 +41,7 @@ cc_fuzz_test(
 
 cc_fuzz_test(
     name = "e2e_fuzz_test",
+    size = "small",
     srcs = ["e2e_fuzz_test.cc"],
     copts = ["-UNDEBUG"],
     corpus = ["//tools/toktok-fuzzer/corpus:e2e_fuzz_test"],
@@ -57,6 +57,7 @@ cc_fuzz_test(
 
 cc_fuzz_test(
     name = "toxsave_fuzz_test",
+    size = "small",
     srcs = ["toxsave_harness.cc"],
     copts = ["-UNDEBUG"],
     corpus = ["//tools/toktok-fuzzer/corpus:toxsave_fuzzer"],
@@ -89,6 +90,7 @@ fuzzing_binary(
 
 cc_fuzz_test(
     name = "protodump_reduce",
+    size = "small",
     srcs = ["protodump_reduce.cc"],
     copts = ["-UNDEBUG"],
     deps = [

external/toxcore/c-toxcore/testing/fuzzing/bootstrap_harness.cc

@@ -107,6 +107,9 @@ void setup_callbacks(Tox_Dispatch *dispatch)
 
 void TestBootstrap(Fuzz_Data &input)
 {
+    // Null system for regularly working memory allocations needed in
+    // tox_events_equal.
+    Null_System null_sys;
     Fuzz_System sys(input);
 
     Ptr<Tox_Options> opts(tox_options_new(nullptr), tox_options_free);
@@ -154,11 +157,9 @@ void TestBootstrap(Fuzz_Data &input)
 
     uint8_t pub_key[TOX_PUBLIC_KEY_SIZE] = {0};
 
-    const bool udp_success = tox_bootstrap(tox, "127.0.0.2", 33446, pub_key, nullptr);
-    assert(udp_success);
-
-    const bool tcp_success = tox_add_tcp_relay(tox, "127.0.0.2", 33446, pub_key, nullptr);
-    assert(tcp_success);
+    // These may fail, but that's ok. We ignore their return values.
+    tox_bootstrap(tox, "127.0.0.2", 33446, pub_key, nullptr);
+    tox_add_tcp_relay(tox, "127.0.0.2", 33446, pub_key, nullptr);
 
     tox_events_init(tox);
 
@@ -169,7 +170,7 @@ void TestBootstrap(Fuzz_Data &input)
     while (input.size > 0) {
         Tox_Err_Events_Iterate error_iterate;
         Tox_Events *events = tox_events_iterate(tox, true, &error_iterate);
-        assert(tox_events_equal(events, events));
+        assert(tox_events_equal(null_sys.sys.get(), events, events));
         tox_dispatch_invoke(dispatch, events, tox, nullptr);
         tox_events_free(events);
         // Move the clock forward a decent amount so all the time-based checks

external/toxcore/c-toxcore/testing/fuzzing/e2e_fuzz_test.cc

@@ -24,7 +24,7 @@ void setup_callbacks(Tox_Dispatch *dispatch)
         });
     tox_events_callback_conference_connected(
         dispatch, [](Tox *tox, const Tox_Event_Conference_Connected *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_conference_invite(
         dispatch, [](Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data) {
@@ -35,19 +35,19 @@ void setup_callbacks(Tox_Dispatch *dispatch)
         });
     tox_events_callback_conference_message(
         dispatch, [](Tox *tox, const Tox_Event_Conference_Message *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_conference_peer_list_changed(dispatch,
         [](Tox *tox, const Tox_Event_Conference_Peer_List_Changed *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_conference_peer_name(
         dispatch, [](Tox *tox, const Tox_Event_Conference_Peer_Name *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_conference_title(
         dispatch, [](Tox *tox, const Tox_Event_Conference_Title *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_file_chunk_request(
         dispatch, [](Tox *tox, const Tox_Event_File_Chunk_Request *event, void *user_data) {
@@ -61,11 +61,11 @@ void setup_callbacks(Tox_Dispatch *dispatch)
         });
     tox_events_callback_file_recv_chunk(
         dispatch, [](Tox *tox, const Tox_Event_File_Recv_Chunk *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_file_recv_control(
         dispatch, [](Tox *tox, const Tox_Event_File_Recv_Control *event, void *user_data) {
-            assert(event == nullptr);
+            assert(event != nullptr);
         });
     tox_events_callback_friend_connection_status(
         dispatch, [](Tox *tox, const Tox_Event_Friend_Connection_Status *event, void *user_data) {
@@ -134,6 +134,8 @@ void setup_callbacks(Tox_Dispatch *dispatch)
 void TestEndToEnd(Fuzz_Data &input)
 {
     Fuzz_System sys(input);
+    // Used for places where we want all allocations to succeed.
+    Null_System null_sys;
 
     Ptr<Tox_Options> opts(tox_options_new(nullptr), tox_options_free);
     assert(opts != nullptr);
@@ -170,7 +172,7 @@ void TestEndToEnd(Fuzz_Data &input)
     while (input.size > 0) {
         Tox_Err_Events_Iterate error_iterate;
         Tox_Events *events = tox_events_iterate(tox, true, &error_iterate);
-        assert(tox_events_equal(events, events));
+        assert(tox_events_equal(null_sys.sys.get(), events, events));
         tox_dispatch_invoke(dispatch, events, tox, nullptr);
         tox_events_free(events);
         // Move the clock forward a decent amount so all the time-based checks

external/toxcore/c-toxcore/testing/fuzzing/fuzz_support.cc

@@ -22,6 +22,8 @@
 
 const bool DEBUG = false;
 
+static constexpr tox_mono_time_cb *get_self_clock = ![](Fuzz_System *self) { return self->clock; };
+
 // TODO(iphydf): Put this somewhere shared.
 struct Network_Addr {
     struct sockaddr_storage addr;
@@ -62,6 +64,33 @@ static int recv_common(Fuzz_Data &input, uint8_t *buf, size_t buf_len)
     return res;
 }
 
+template <typename F>
+static void *alloc_common(Fuzz_Data &data, F func)
+{
+    CONSUME1_OR_RETURN_VAL(const uint8_t want_alloc, data, func());
+    if (!want_alloc) {
+        return nullptr;
+    }
+    return func();
+}
+
+static constexpr Memory_Funcs fuzz_memory_funcs = {
+    /* .malloc = */
+    ![](Fuzz_System *self, uint32_t size) {
+        return alloc_common(self->data, [=]() { return std::malloc(size); });
+    },
+    /* .calloc = */
+    ![](Fuzz_System *self, uint32_t nmemb, uint32_t size) {
+        return alloc_common(self->data, [=]() { return std::calloc(nmemb, size); });
+    },
+    /* .realloc = */
+    ![](Fuzz_System *self, void *ptr, uint32_t size) {
+        return alloc_common(self->data, [=]() { return std::realloc(ptr, size); });
+    },
+    /* .free = */
+    ![](Fuzz_System *self, void *ptr) { std::free(ptr); },
+};
+
 static constexpr Network_Funcs fuzz_network_funcs = {
     /* .close = */ ![](Fuzz_System *self, int sock) { return 0; },
     /* .accept = */ ![](Fuzz_System *self, int sock) { return 1337; },
@@ -149,17 +178,30 @@ static constexpr Random_Funcs fuzz_random_funcs = {
 Fuzz_System::Fuzz_System(Fuzz_Data &input)
     : System{
         std::make_unique<Tox_System>(),
+        std::make_unique<Memory>(Memory{&fuzz_memory_funcs, this}),
         std::make_unique<Network>(Network{&fuzz_network_funcs, this}),
         std::make_unique<Random>(Random{&fuzz_random_funcs, this}),
     }
     , data(input)
 {
-    sys->mono_time_callback = ![](Fuzz_System *self) { return self->clock; };
+    sys->mono_time_callback = get_self_clock;
     sys->mono_time_user_data = this;
+    sys->mem = mem.get();
     sys->ns = ns.get();
     sys->rng = rng.get();
 }
 
+static constexpr Memory_Funcs null_memory_funcs = {
+    /* .malloc = */
+    ![](Null_System *self, uint32_t size) { return std::malloc(size); },
+    /* .calloc = */
+    ![](Null_System *self, uint32_t nmemb, uint32_t size) { return std::calloc(nmemb, size); },
+    /* .realloc = */
+    ![](Null_System *self, void *ptr, uint32_t size) { return std::realloc(ptr, size); },
+    /* .free = */
+    ![](Null_System *self, void *ptr) { std::free(ptr); },
+};
+
 static constexpr Network_Funcs null_network_funcs = {
     /* .close = */ ![](Null_System *self, int sock) { return 0; },
     /* .accept = */ ![](Null_System *self, int sock) { return 1337; },
@@ -224,12 +266,14 @@ static constexpr Random_Funcs null_random_funcs = {
 Null_System::Null_System()
     : System{
         std::make_unique<Tox_System>(),
+        std::make_unique<Memory>(Memory{&null_memory_funcs, this}),
         std::make_unique<Network>(Network{&null_network_funcs, this}),
         std::make_unique<Random>(Random{&null_random_funcs, this}),
     }
 {
-    sys->mono_time_callback = ![](Fuzz_System *self) { return self->clock; };
+    sys->mono_time_callback = get_self_clock;
     sys->mono_time_user_data = this;
+    sys->mem = mem.get();
     sys->ns = ns.get();
     sys->rng = rng.get();
 }
@@ -244,6 +288,8 @@ static uint16_t get_port(const Network_Addr *addr)
     }
 }
 
+static constexpr Memory_Funcs record_memory_funcs = null_memory_funcs;
+
 static constexpr Network_Funcs record_network_funcs = {
     /* .close = */ ![](Record_System *self, int sock) { return 0; },
     /* .accept = */ ![](Record_System *self, int sock) { return 2; },
@@ -348,6 +394,7 @@ static constexpr Random_Funcs record_random_funcs = {
 Record_System::Record_System(Global &global, uint64_t seed, const char *name)
     : System{
         std::make_unique<Tox_System>(),
+        std::make_unique<Memory>(Memory{&record_memory_funcs, this}),
         std::make_unique<Network>(Network{&record_network_funcs, this}),
         std::make_unique<Random>(Random{&record_random_funcs, this}),
     }
@@ -355,8 +402,9 @@ Record_System::Record_System(Global &global, uint64_t seed, const char *name)
     , seed_(seed)
     , name_(name)
 {
-    sys->mono_time_callback = ![](Fuzz_System *self) { return self->clock; };
+    sys->mono_time_callback = get_self_clock;
     sys->mono_time_user_data = this;
+    sys->mem = mem.get();
     sys->ns = ns.get();
     sys->rng = rng.get();
 }

external/toxcore/c-toxcore/testing/fuzzing/fuzz_support.h

@@ -59,6 +59,23 @@ struct Fuzz_Data {
     }                                   \
     DECL = INPUT.consume1()
 
+/** @brief Consumes 1 byte of the fuzzer input or returns a value if no data
+ * available.
+ *
+ * This advances the fuzzer input data by 1 byte and consumes that byte in the
+ * declaration.
+ *
+ * @example
+ * @code
+ * 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()
+
 /** @brief Consumes SIZE bytes of the fuzzer input or returns if not enough data available.
  *
  * This advances the fuzzer input data by SIZE byte and consumes those bytes in
@@ -100,11 +117,13 @@ void fuzz_select_target(const uint8_t *data, std::size_t size, Args &&... args)
     return fuzz_select_target(selector, input, std::forward<Args>(args)...);
 }
 
+struct Memory;
 struct Network;
 struct Random;
 
 struct System {
     std::unique_ptr<Tox_System> sys;
+    std::unique_ptr<Memory> mem;
     std::unique_ptr<Network> ns;
     std::unique_ptr<Random> rng;
 

external/toxcore/c-toxcore/testing/fuzzing/fuzz_tox.h

@@ -62,13 +62,14 @@ struct with<IP_Port> {
 
 /** @brief Construct a Networking_Core object using the Network vtable passed.
  *
- * Use `with<Logger>{} >> with<Networking_Core>{input, ns} >> ...` to construct
+ * Use `with<Logger>{} >> with<Networking_Core>{input, ns, mem} >> ...` to construct
  * a logger and pass it to the Networking_Core constructor function.
  */
 template <>
 struct with<Networking_Core> {
     Fuzz_Data &input_;
     const Network *ns_;
+    const Memory *mem_;
     Ptr<Logger> logger_{nullptr, logger_kill};
 
     friend with operator>>(with<Logger> f, with self)
@@ -82,7 +83,7 @@ struct with<Networking_Core> {
     {
         with<IP_Port>{input_} >> [&f, this](const IP_Port &ipp) {
             Ptr<Networking_Core> net(
-                new_networking_ex(logger_.get(), ns_, &ipp.ip, ipp.port, ipp.port + 100, nullptr),
+                new_networking_ex(logger_.get(), mem_, ns_, &ipp.ip, ipp.port, ipp.port + 100, nullptr),
                 kill_networking);
             if (net == nullptr) {
                 return;

external/toxcore/c-toxcore/testing/fuzzing/protodump.cc

@@ -20,6 +20,7 @@
  *   bazel build //c-toxcore/testing/fuzzing:protodump_bin && \
  *     bazel-bin/c-toxcore/testing/fuzzing/protodump_bin
  */
+#include <array>
 #include <cassert>
 #include <cstdio>
 #include <cstring>
@@ -243,12 +244,12 @@ void RecordBootstrap()
         Tox_Events *events;
 
         events = tox_events_iterate(tox1, true, &error_iterate);
-        assert(tox_events_equal(events, events));
+        assert(tox_events_equal(sys1.sys.get(), events, events));
         tox_dispatch_invoke(dispatch, events, tox1, &done1);
         tox_events_free(events);
 
         events = tox_events_iterate(tox2, true, &error_iterate);
-        assert(tox_events_equal(events, events));
+        assert(tox_events_equal(sys2.sys.get(), events, events));
         tox_dispatch_invoke(dispatch, events, tox2, &done2);
         tox_events_free(events);
 

external/toxcore/c-toxcore/testing/fuzzing/protodump_reduce.cc

@@ -172,7 +172,7 @@ void TestEndToEnd(Fuzz_Data &input)
     while (input.size > 0) {
         Tox_Err_Events_Iterate error_iterate;
         Tox_Events *events = tox_events_iterate(tox, true, &error_iterate);
-        assert(tox_events_equal(events, events));
+        assert(tox_events_equal(tox_get_system(tox), events, events));
         tox_dispatch_invoke(dispatch, events, tox, nullptr);
         tox_events_free(events);
         sys.clock += std::max(System::MIN_ITERATION_INTERVAL, random_u08(sys.rng.get()));

external/toxcore/c-toxcore/third_party/BUILD.bazel

@@ -1,7 +1,5 @@
 load("//tools:no_undefined.bzl", "cc_library")
 
-package(features = ["layering_check"])
-
 cc_library(
     name = "cmp",
     srcs = ["cmp/cmp.c"],

external/toxcore/c-toxcore/toxav/BUILD.bazel

@@ -1,8 +1,6 @@
 load("@rules_cc//cc:defs.bzl", "cc_test")
 load("//tools:no_undefined.bzl", "cc_library")
 
-package(features = ["layering_check"])
-
 exports_files(
     srcs = ["toxav.h"],
     visibility = ["//c-toxcore:__pkg__"],
@@ -54,6 +52,7 @@ cc_library(
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
+        "//c-toxcore/toxcore:tox",
         "//c-toxcore/toxcore:util",
     ],
 )
@@ -68,6 +67,7 @@ cc_library(
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
+        "//c-toxcore/toxcore:tox",
         "//c-toxcore/toxcore:util",
     ],
 )
@@ -94,6 +94,7 @@ cc_library(
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
+        "//c-toxcore/toxcore:util",
         "@opus",
     ],
 )
@@ -113,6 +114,7 @@ cc_library(
         ":public_api",
         ":ring_buffer",
         ":rtp",
+        "//c-toxcore/toxcore:Messenger",
         "//c-toxcore/toxcore:ccompat",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
@@ -129,6 +131,7 @@ cc_library(
     deps = [
         "//c-toxcore/toxcore",
         "//c-toxcore/toxcore:ccompat",
+        "//c-toxcore/toxcore:group",
         "//c-toxcore/toxcore:logger",
         "//c-toxcore/toxcore:mono_time",
         "//c-toxcore/toxcore:tox",