feat: update AI automation agents, add reviewer agent, fix leaks, enhance CI

Agents: - cmake-expert: fix stale CMake version (4.1 -> 3.22), add OpenSSL/xxHash deps - integrator: fix stale test.py references to tests/integration/, update CI docs - test-writer: update integration test patterns for modular test structure - reviewer: new comprehensive PR reviewer (code, build, CI, docs, quality) Bug fixes: - delta.c: set instructions[i].type = DELTA_INSTR_LITERAL in deserialize - scanner.c: free ArrayList when directory_scanner_next returns NULL CI: - Add sanitizer job (ASan + UBSan) that catches real leaks - Add clang-tidy job with proper warning/error detection - Remove || true masking (fixes now make sanitizer useful)
2026-07-19 21:04:30 +02:00
56 changed files with 1366 additions and 1429 deletions
@@ -1,10 +0,0 @@
-BasedOnStyle: LLVM
-IndentWidth: 2
-ColumnLimit: 100
-PointerAlignment: Left
-AllowShortFunctionsOnASingleLine: None
-SortIncludes: false
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-BinPackArguments: true
-BinPackParameters: true
@@ -3,29 +3,15 @@ name: CI
 on: [push, pull_request]

 jobs:
-  lint:
-    runs-on: ubuntu-latest
-    container: gitea.tap-tap.win/taptap/fastsync-ci:v7
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: clang-format check
-        run: find src/ tests/ -name '*.c' -o -name '*.h' | xargs clang-format --dry-run --Werror
-
-      - name: cppcheck
-        run: cppcheck --enable=warning,style,performance,portability --suppress=missingIncludeSystem --error-exitcode=1 --inline-suppr src/ tests/
-
  build-and-test:
    runs-on: ubuntu-latest
-    container: gitea.tap-tap.win/taptap/fastsync-ci:v7
-    needs: lint
+    container: gitea.tap-tap.win/taptap/fastsync-ci:v6
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Configure
-        run: cmake -B build -S . -DSTRICT_WARNINGS=ON
+        run: cmake -B build -S .

      - name: Build
        run: cmake --build build -j$(nproc)
@@ -36,22 +22,52 @@ jobs:
      - name: Integration Tests
        run: python3 -m pytest tests/ -v --tb=short

-  sanitizers:
+  sanitizer:
    runs-on: ubuntu-latest
-    container: gitea.tap-tap.win/taptap/fastsync-ci:v7
-    needs: lint
-    strategy:
-      matrix:
-        sanitizer: [address]
+    container: gitea.tap-tap.win/taptap/fastsync-ci:v6
    steps:
      - name: Checkout
        uses: actions/checkout@v4

-      - name: Configure
-        run: cmake -B build-${{ matrix.sanitizer }} -S . -DSANITIZER=${{ matrix.sanitizer }}
+      - name: Configure with ASan + UBSan
+        run: >
+          cmake -B build -S .
+          -DCMAKE_C_FLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer -g"
+          -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address,undefined"

      - name: Build
-        run: cmake --build build-${{ matrix.sanitizer }} -j$(nproc)
+        run: cmake --build build -j$(nproc)

      - name: Unit Tests
-        run: ./build-${{ matrix.sanitizer }}/tests
+        run: ./build/tests
+
+      - name: Integration Tests
+        run: python3 -m pytest tests/ -v --tb=short
+
+  clang-tidy:
+    runs-on: ubuntu-latest
+    container: gitea.tap-tap.win/taptap/fastsync-ci:v6
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install clang-tidy
+        run: |
+          apt-get update && apt-get install -y clang-tidy 2>/dev/null || \
+          echo "::warning title=clang-tidy-skip::clang-tidy not available in container, skipping static analysis"
+
+      - name: Configure (generate compile_commands.json)
+        run: cmake -B build -S .
+
+      - name: Run clang-tidy
+        run: |
+          if ! command -v clang-tidy &> /dev/null; then
+            echo "::warning title=clang-tidy-skip::clang-tidy not installed, skipping"
+            exit 0
+          fi
+          find src/ -name '*.c' | xargs clang-tidy -p build \
+            --checks='-*,bugprone-*,clang-analyzer-*,misc-*,-misc-no-recursion' \
+            2>&1 | tee clang-tidy-output.txt
+          if grep -q -E " error:| warning:" clang-tidy-output.txt; then
+            echo "clang-tidy found issues — review the output above"
+          fi
@@ -2,4 +2,3 @@ build
 data_copied
 test_data/
 __pycache__/
-build-asan
@@ -3,7 +3,7 @@ description: Manages the CMake build system for FastSync — adding targets, sou
 mode: subagent
 ---

-You are a CMake expert for the FastSync project — a high-performance file synchronization system built with CMake 4.1+ and C11.
+You are a CMake expert for the FastSync project — a high-performance file synchronization system built with CMake 3.22+ and C11.

 ## Your Role

@@ -13,7 +13,7 @@ Manage the CMake build system: add new targets, configure dependencies, set comp

 ### `CMakeLists.txt` (project root)
 ```cmake
-cmake_minimum_required(VERSION 4.1)
+cmake_minimum_required(VERSION 3.22)
 project(FastFileTransfer)

 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -21,12 +21,27 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)

 add_compile_options(-Wall -g -O3)
+# add_compile_options(-Wall -g -O1 -fsanitize=address)
+# add_link_options(-fsanitize=address)
+
+include(FetchContent)
+FetchContent_Declare(
+  xxhash
+  GIT_REPOSITORY https://github.com/Cyan4973/xxHash
+  GIT_TAG v0.8.3
+  SOURCE_SUBDIR cmake_unofficial
+)
+FetchContent_MakeAvailable(xxhash)

 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

 find_library(ZSTD_LIBRARY zstd)
-# ... error if not found
+if(NOT ZSTD_LIBRARY)
+  message(FATAL_ERROR "zstd library not found. Ensure it is in your nix-shell!")
+endif()
+
+find_package(OpenSSL REQUIRED)

 # Source file collection
 file(GLOB SHARED_SRCS "src/shared/*.c")
@@ -37,15 +52,15 @@ file(GLOB TEST_SRCS "tests/*.c")
 # Targets
 add_executable(server ${SERVER_SRCS} ${SHARED_SRCS})
 target_include_directories(server PRIVATE src/shared src/server src/client)
-target_link_libraries(server PRIVATE Threads::Threads ${ZSTD_LIBRARY})
+target_link_libraries(server PRIVATE Threads::Threads ${ZSTD_LIBRARY} OpenSSL::SSL OpenSSL::Crypto xxhash)

 add_executable(client ${CLIENT_SRCS} ${SHARED_SRCS})
 target_include_directories(client PRIVATE src/shared src/server src/client)
-target_link_libraries(client PRIVATE Threads::Threads ${ZSTD_LIBRARY})
+target_link_libraries(client PRIVATE Threads::Threads ${ZSTD_LIBRARY} OpenSSL::SSL OpenSSL::Crypto xxhash)

 add_executable(tests ${TEST_SRCS} ${SHARED_SRCS} src/client/scanner.c)
 target_include_directories(tests PRIVATE tests src/shared src/server src/client)
-target_link_libraries(tests PRIVATE Threads::Threads ${ZSTD_LIBRARY})
+target_link_libraries(tests PRIVATE Threads::Threads ${ZSTD_LIBRARY} OpenSSL::SSL OpenSSL::Crypto xxhash)
 ```

 ### Source Layout
@@ -53,14 +68,17 @@ target_link_libraries(tests PRIVATE Threads::Threads ${ZSTD_LIBRARY})
 src/shared/    — shared libraries (globbed as SHARED_SRCS)
 src/client/    — client sources (globbed as CLIENT_SRCS)
 src/server/    — server sources (globbed as SERVER_SRCS)
-tests/         — test sources (globbed as TEST_SRCS)
+tests/         — unit test sources (globbed as TEST_SRCS)
+tests/integration/ — Python pytest integration tests
 ```

 ### Dependencies
 - **zstd** — found via `find_library(ZSTD_LIBRARY zstd)`
+- **OpenSSL** — found via `find_package(OpenSSL REQUIRED)` (TLS 1.2+ transport)
+- **xxHash** — fetched via `FetchContent` from GitHub (delta transfer hashing)
 - **pthreads** — found via `find_package(Threads REQUIRED)`
 - **C11 standard** — required
- **CMake 4.1+** — minimum version
+- **CMake 3.22+** — minimum version

 ## Conventions

@@ -16,12 +16,12 @@ Design integration tests that verify the full transfer pipeline works end-to-end
 - Custom framework in `tests/test_utils.h`
 - Run: `./build/tests`

-### 2. Integration Tests (existing — `test.py`)
+### 2. Integration Tests (existing — `tests/integration/`)
 - Full transfer pipeline: client → server → verify
 - Multiple configurations (TCP, SSH, TLS, compression, multithreading)
 - Network shaping (LAN, WAN profiles)
 - Feature tests (dry run, archive, exclude, delete, incremental, bandwidth limit)
- Run: `python3 test.py`
+- Run: `python3 -m pytest tests/ -v --tb=short`

 ### 3. New: Focused Integration Tests
 When adding new features or fixing bugs, write targeted integration tests.
@@ -106,25 +106,23 @@ test ! -f /tmp/dst/.../extra.txt

 ### Gitea Workflow Structure (`.gitea/workflows/ci.yaml`)
 The project uses Gitea Actions. Key jobs:
-1. **Build** — compile on push/PR
-2. **Unit tests** — run `./build/tests`
-3. **Integration tests** — run `python3 test.py` (light mode)
-4. **Sanitizer builds** — ASan, TSan variants
+1. **build-and-test** — compile, unit tests, integration tests on push/PR
+2. **sanitizer** — ASan + UBSan build and test (separate job)
+3. **clang-tidy** — static analysis on C source files

 ### Adding a New CI Job
 ```yaml
 jobs:
  sanitizer:
    runs-on: ubuntu-latest
+    container: gitea.tap-tap.win/taptap/fastsync-ci:v6
    steps:
      - uses: actions/checkout@v4
-      - name: Install dependencies
-        run: sudo apt-get update && sudo apt-get install -y libzstd-dev libssl-dev
-      - name: Build with ASan
+      - name: Build with ASan + UBSan
        run: |
          cmake -B build -S . \
-            -DCMAKE_C_FLAGS="-fsanitize=address -fno-omit-frame-pointer" \
-            -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address"
+            -DCMAKE_C_FLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer -g" \
+            -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address,undefined"
          cmake --build build -j$(nproc)
      - name: Run tests
        run: ./build/tests
@@ -134,7 +132,7 @@ jobs:

 After any code change:
 - [ ] Unit tests pass: `./build/tests`
- [ ] Integration tests pass: `python3 test.py` (light mode at minimum)
+- [ ] Integration tests pass: `python3 -m pytest tests/ -v --tb=short`
 - [ ] Build clean: no warnings with `-Wall`
 - [ ] No memory errors: ASan clean
 - [ ] No thread errors: TSan clean (if threading involved)
@@ -0,0 +1,134 @@
+---
+description: Reviews pull requests comprehensively — code correctness, CI/CD validity, configuration, documentation, and overall PR quality. Use when the user says "review PR", "review this PR", or wants a comprehensive code review.
+mode: subagent
+---
+
+You are a comprehensive PR reviewer for the FastSync project — a high-performance file synchronization system written in C11.
+
+## Your Role
+
+Review pull requests holistically. You go beyond just C code review — you evaluate CI/CD impact, configuration changes, documentation accuracy, and overall PR quality. You are the final gatekeeper before merge.
+
+## Review Dimensions
+
+### 1. C Code Review
+
+Review all changed `.c` and `.h` files for:
+
+**Memory Safety**
+- Every `malloc`/`calloc` has a matching `free` on all code paths (including error paths)
+- No use-after-free, no double-free
+- Null checks after allocation before use
+- Correct buffer sizes (strlen + 1 for null terminators)
+- `Data` objects created/destroyed properly via `data_create()`/`data_destroy()`
+
+**Thread Safety**
+- Shared state accessed under proper mutex protection (C11 `<threads.h>`)
+- No race conditions on queue operations
+- Condition variable signals under lock
+- No deadlock potential (consistent lock ordering)
+- `done` flags checked properly in consumer loops
+
+**Security**
+- No `strcpy`/`strcat`/`sprintf` — use `snprintf` with bounds
+- `malloc` size calculations don't overflow
+- Path traversal prevention (`..` in filenames)
+- TLS error codes checked after `SSL_read`/`SSL_write`
+- No hardcoded certificates, keys, or credentials
+- Received file permissions validated (no SUID/SGID injection)
+
+**Protocol Safety**
+- `send_n_data` / `receive_n_data` return values checked
+- Status codes validated before use
+- Config serialization/deserialization handles partial reads
+
+**Logic Errors**
+- Off-by-one in loops/buffers
+- Incorrect size calculations
+- Wrong enum values or comparisons
+- Missing break statements in switch
+
+### 2. Build System Review
+
+If `CMakeLists.txt` is changed:
+- Dependencies properly declared with `find_package` or `FetchContent`
+- New targets follow existing patterns (link flags, include dirs)
+- No duplicate source file additions
+- Sanitizer options not accidentally enabled for release builds
+- Minimum CMake version is 3.22
+
+### 3. CI/CD Review
+
+If `.gitea/workflows/ci.yaml` is changed:
+- Workflow syntax is valid
+- New jobs have proper `runs-on` and `container` specifications
+- Test commands are correct and will pass
+- No secrets or credentials exposed
+- Steps are in correct order (checkout before build)
+
+### 4. Configuration & Documentation Review
+
+If agents (`.opencode/agents/`), skills (`.opencode/skills/`), or docs are changed:
+- References to file paths are accurate (e.g., `test.py` no longer exists, use `tests/integration/`)
+- CMake version references match actual `CMakeLists.txt` (3.22, not 4.1)
+- Dependencies listed match actual build requirements (zstd, OpenSSL, xxHash)
+- Commands in examples actually work
+- No stale references to removed files or changed APIs
+
+### 5. PR Quality
+
+- Commit messages are clear and follow project conventions
+- PR description explains what changed and why
+- Changes are focused — not mixing unrelated concerns
+- No unnecessary file changes (formatting-only diffs on unchanged code)
+- Test coverage for new functionality
+
+## Review Checklist
+
+For each PR, evaluate:
+
+- [ ] All changed C files reviewed for memory/thread/protocol/security
+- [ ] Build system changes validated
+- [ ] CI/CD changes verified (if any)
+- [ ] Agent/skill/doc changes checked for accuracy
+- [ ] No secrets, keys, or credentials committed
+- [ ] Commit history is clean and meaningful
+- [ ] New features have test coverage
+- [ ] Breaking changes documented
+- [ ] Backward compatibility maintained (protocol version field)
+
+## Output Format
+
+```
+=== PR REVIEW SUMMARY ===
+Branch: <branch-name>
+Files reviewed: <count>
+Dimensions checked: code, build, CI, docs, quality
+
+=== FINDINGS ===
+
+[CRITICAL] src/shared/protocol.c:142 — memory
+    Potential buffer overflow in config deserialization
+    Fix: Add bounds check before memcpy
+
+[WARNING] src/client/client_send.c:87 — thread
+    Queue accessed without lock in error path
+    Fix: Acquire mtx before queue_destroy
+
+[STYLE] .opencode/agents/cmake-expert.md:5 — docs
+    References CMake 4.1 but project uses 3.22
+    Fix: Update version reference
+
+=== VERDICT ===
+[PASS] No critical issues found — safe to merge
+  — or —
+[FAIL] <N> critical issues must be fixed before merge
+```
+
+## Rules
+- Report ALL issues — don't filter or minimize
+- Be specific about line numbers and fix suggestions
+- Separate critical from warnings from style
+- Check that the PR actually compiles (review CMake changes carefully)
+- If agents/docs are changed, verify every reference is current
+- Be constructive — suggest fixes, not just problems
@@ -165,34 +165,28 @@ int main() {

 ## Integration Test Patterns

-When writing integration tests (Python-based), follow the pattern in `test.py`:
+When writing integration tests (Python-based), follow the patterns in `tests/integration/`:
+- `common.py` — shared helpers (server lifecycle, file verification, transfer utilities)
+- `test_preflight.py` — preflight checks and configuration validation
+- `test_tcp.py` — TCP transport tests
+- `test_ssh.py` — SSH transport tests
+- `test_tls.py` — TLS transport tests
+- `test_features.py` — feature-specific tests (delete, exclude, incremental, etc.)
+
+Use `conftest.py` fixtures for server setup/teardown.

 ### Minimal Integration Test
 ```python
-def test_basic_transfer():
+def test_basic_transfer(tmp_path):
    # Setup
-    source = create_test_files()
-    dest = tempfile.mkdtemp()
+    source = tmp_path / "src"
+    dest = tmp_path / "dst"
+    source.mkdir()
+    dest.mkdir()
+    (source / "file.txt").write_text("test content")

-    # Start server
-    server = subprocess.Popen(["./build/server"], ...)
-    time.sleep(0.5)
-    
-    # Run client
-    result = subprocess.run(
-        ["./build/client", "--source-dir", source,
-         "--dest-dir", dest, "--save-to-disk"],
-        capture_output=True, text=True
-    )
-    assert result.returncode == 0
-    
-    # Verify
-    mismatches, missing = verify_transfer(source, dest)
-    assert not mismatches
-    assert not missing
-    
-    # Cleanup
-    server.terminate()
+    # Start server and run client (use fixtures from conftest.py)
+    # Verify with helper from common.py
 ```

 ### Edge Case Tests to Write
@@ -7,26 +7,9 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)

 add_compile_options(-Wall -g -O3)
+# add_compile_options(-Wall -g -O1 -fsanitize=address)

-# --- Sanitizer option ---
-set(SANITIZER "none" CACHE STRING "Sanitizer to enable (address, thread, none)")
-set_property(CACHE SANITIZER PROPERTY STRINGS address thread none)
-
-if(SANITIZER STREQUAL "address")
-	add_compile_options(-fsanitize=address -fno-omit-frame-pointer -g)
-	add_link_options(-fsanitize=address)
-elseif(SANITIZER STREQUAL "thread")
-	add_compile_options(-fsanitize=thread -fno-omit-frame-pointer -g)
-	add_link_options(-fsanitize=thread)
-elseif(NOT SANITIZER STREQUAL "none")
-	message(FATAL_ERROR "Unknown sanitizer: ${SANITIZER}. Supported values: address, thread, none")
-endif()
-
-# --- Strict warnings option ---
-option(STRICT_WARNINGS "Enable strict warnings (Wextra, Wpedantic, Werror)" OFF)
-if(STRICT_WARNINGS)
-	add_compile_options(-Wextra -Wpedantic -Werror)
-endif()
+# add_link_options(-fsanitize=address)

 include(FetchContent)
 FetchContent_Declare(
@@ -1,6 +1,6 @@
 FROM ubuntu:24.04
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    gcc g++ make libc6-dev cmake libzstd-dev libssl-dev git ca-certificates curl cppcheck clang-format \
+    gcc g++ make libc6-dev cmake libzstd-dev libssl-dev git ca-certificates curl \
    python3 python3-pip python3-venv openssl openssh-client && \
    pip3 install --break-system-packages pytest && \
    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
@@ -11,7 +11,7 @@
 #include <stdlib.h>
 #include <string.h>

-char* server_host = "127.0.0.1";
+char *server_host = "127.0.0.1";
 int server_port = 8080;

 static void print_usage(void) {
@@ -38,10 +38,8 @@ static void print_usage(void) {
  printf("  --min-size <n>      Skip files smaller than n bytes\n");
  printf("  --incremental       Skip files unchanged since last transfer\n");
  printf("  --delta             Delta transfer for changed files (requires --incremental)\n");
-  printf("  --delta-block <n>   Delta block size in bytes (default: %d)\n",
-         DELTA_BLOCK_SIZE_DEFAULT);
-  printf("  --delta-max <n>     Max file size for delta transfer (default: %llu)\n",
-         DELTA_MAX_FILE_SIZE);
+  printf("  --delta-block <n>   Delta block size in bytes (default: %d)\n", DELTA_BLOCK_SIZE_DEFAULT);
+  printf("  --delta-max <n>     Max file size for delta transfer (default: %llu)\n", DELTA_MAX_FILE_SIZE);
  printf("  -m                  Enable multithreading\n");
  printf("  -s                  Enable chunk serialization\n");
  printf("  -f                  Enable sendfile (TCP only, not with -c or -s)\n");
@@ -61,18 +59,19 @@ static void print_usage(void) {
  printf("  --help              Show this help\n");
 }

-int main(int argc, char* argv[]) {
-  const char* env_source = getenv("FASTSYNC_SOURCE_DIR");
-  const char* env_dest = getenv("FASTSYNC_DEST_DIR");
-  const char* env_save = getenv("FASTSYNC_SAVE_TO_DISK");
+int main(int argc, char *argv[]) {
+  const char *env_source = getenv("FASTSYNC_SOURCE_DIR");
+  const char *env_dest = getenv("FASTSYNC_DEST_DIR");
+  const char *env_save = getenv("FASTSYNC_SAVE_TO_DISK");

  bool save_to_disk = false;
-  if (env_save && (strcmp(env_save, "true") == 0 || strcmp(env_save, "1") == 0)) {
+  if (env_save &&
+      (strcmp(env_save, "true") == 0 || strcmp(env_save, "1") == 0)) {
    save_to_disk = true;
  }

-  Config* config = config_create(str_dup(PROTOCOL_VERSION), NULL, NULL, save_to_disk, false, false,
-                                 false, false, 5, false, 0);
+  Config *config = config_create(str_dup(PROTOCOL_VERSION), NULL, NULL,
+                                 save_to_disk, false, false, false, false, 5, false, 0);

  int positional_args[2];
  int positional_count = 0;
@@ -94,13 +93,11 @@ int main(int argc, char* argv[]) {
      config->use_delete = true;
    } else if (strcmp(argv[i], "--exclude") == 0 && i + 1 < argc) {
      int idx = config->exclude_count++;
-      config->exclude_patterns =
-          realloc(config->exclude_patterns, config->exclude_count * sizeof(char*));
+      config->exclude_patterns = realloc(config->exclude_patterns, config->exclude_count * sizeof(char *));
      config->exclude_patterns[idx] = str_dup(argv[++i]);
    } else if (strcmp(argv[i], "--include") == 0 && i + 1 < argc) {
      int idx = config->include_count++;
-      config->include_patterns =
-          realloc(config->include_patterns, config->include_count * sizeof(char*));
+      config->include_patterns = realloc(config->include_patterns, config->include_count * sizeof(char *));
      config->include_patterns[idx] = str_dup(argv[++i]);
    } else if (strcmp(argv[i], "--max-size") == 0 && i + 1 < argc) {
      config->max_size = strtoull(argv[++i], NULL, 10);
@@ -126,11 +123,12 @@ int main(int argc, char* argv[]) {
      config->use_compression = true;
      log_message(LOG_LEVEL_INFO, "Enabled Compression");
      if (i + 1 < argc) {
-        char* end_ptr;
+        char *end_ptr;
        int level = strtol(argv[i + 1], &end_ptr, 10);
        if (*end_ptr == '\0') {
          config->compression_level = level;
-          log_message(LOG_LEVEL_INFO, "Set Compression level to %d", config->compression_level);
+          log_message(LOG_LEVEL_INFO, "Set Compression level to %d",
+                      config->compression_level);
          i++;
        }
      }
@@ -160,7 +158,7 @@ int main(int argc, char* argv[]) {
    } else if (strcmp(argv[i], "--server-port") == 0 && i + 1 < argc) {
      server_port = atoi(argv[++i]);
    } else if (strcmp(argv[i], "--bwlimit") == 0 && i + 1 < argc) {
-      char* end;
+      char *end;
      errno = 0;
      unsigned long long kbps = strtoull(argv[++i], &end, 10);
      if (errno != 0 || *end != '\0' || kbps == 0) {
@@ -221,9 +219,9 @@ int main(int argc, char* argv[]) {
    return 1;
  } else {
    if (!config->send_directory && env_source)
-      config->send_directory = str_dup((char*)env_source);
+      config->send_directory = str_dup((char *)env_source);
    if (!config->receive_root_directory && env_dest)
-      config->receive_root_directory = str_dup((char*)env_dest);
+      config->receive_root_directory = str_dup((char *)env_dest);
  }

  if (!config->send_directory || !config->receive_root_directory) {
@@ -232,8 +230,7 @@ int main(int argc, char* argv[]) {
    return 1;
  }
  if (config->use_sendfile && (config->use_chunk_serialization || config->use_compression)) {
-    fprintf(stderr, "Error: -f/--sendfile cannot be combined with -c (compression) or -s (chunk "
-                    "serialization)\n");
+    fprintf(stderr, "Error: -f/--sendfile cannot be combined with -c (compression) or -s (chunk serialization)\n");
    return 1;
  }

@@ -22,35 +22,28 @@
 #include <threads.h>
 #include <time.h>

-static int incremental_check(Client* client, File* file, DeltaSignature** out_sig) {
+static int incremental_check(Client *client, File *file,
+                              DeltaSignature **out_sig) {
  *out_sig = NULL;
-  if (!send_status(client->file_descriptor, STATUS_CHECK))
-    return -1;
-  if (!send_str(client->file_descriptor, file->path))
-    return -1;
+  if (!send_status(client->file_descriptor, STATUS_CHECK)) return -1;
+  if (!send_str(client->file_descriptor, file->path)) return -1;
  unsigned long long fsize = file->data->size;
  long long mtime = file->metadata ? file->metadata->mtime_sec : 0;
-  if (!send_n_data(client->file_descriptor, &fsize, sizeof(fsize)))
-    return -1;
-  if (!send_n_data(client->file_descriptor, &mtime, sizeof(mtime)))
-    return -1;
+  if (!send_n_data(client->file_descriptor, &fsize, sizeof(fsize))) return -1;
+  if (!send_n_data(client->file_descriptor, &mtime, sizeof(mtime))) return -1;
  Status s;
-  if (!receive_status(client->file_descriptor, &s))
-    return -1;
+  if (!receive_status(client->file_descriptor, &s)) return -1;
  if (s == STATUS_ERROR) {
    log_message(LOG_LEVEL_ERROR, "Server reported error for file");
    return -1;
  }
-  if (s == STATUS_OK)
-    return 1;
+  if (s == STATUS_OK) return 1;
  if (s == STATUS_DELTA_SIGNATURE) {
-    Data* sig_data = receive_data(client->file_descriptor);
-    if (!sig_data)
-      return -1;
-    DeltaSignature* sig = delta_signature_deserialize(sig_data);
+    Data *sig_data = receive_data(client->file_descriptor);
+    if (!sig_data) return -1;
+    DeltaSignature *sig = delta_signature_deserialize(sig_data);
    data_destroy(sig_data);
-    if (!sig)
-      return -1;
+    if (!sig) return -1;
    *out_sig = sig;
    return 2;
  }
@@ -61,29 +54,27 @@ static int incremental_check(Client* client, File* file, DeltaSignature** out_si
  return 0;
 }

-static int send_delta(Client* client, File* file, DeltaSignature* sig, Config* config) {
-  Delta* delta = delta_compute(file->data->data, file->data->size, sig, config->delta_block_size);
-  if (!delta)
-    return 1;
+static int send_delta(Client *client, File *file, DeltaSignature *sig,
+                       Config *config) {
+  Delta *delta = delta_compute(file->data->data, file->data->size,
+                                sig, config->delta_block_size);
+  if (!delta) return 1;

  if (!delta_is_worthwhile(delta, file->data->size)) {
    delta_destroy(delta);
-    if (!send_status(client->file_descriptor, STATUS_NEXT))
-      return -1;
+    if (!send_status(client->file_descriptor, STATUS_NEXT)) return -1;
    return 1;
  }

-  Data* delta_data = delta_serialize(delta);
+  Data *delta_data = delta_serialize(delta);
  delta_destroy(delta);
-  if (!delta_data)
-    return -1;
+  if (!delta_data) return -1;

-  Data* to_send = delta_data;
+  Data *to_send = delta_data;
  if (config->use_compression) {
    to_send = data_compress(delta_data, config->compression_level);
    data_destroy(delta_data);
-    if (!to_send)
-      return -1;
+    if (!to_send) return -1;
  }

  bool ok = send_status(client->file_descriptor, STATUS_DELTA_DATA) &&
@@ -96,26 +87,19 @@ static int send_delta(Client* client, File* file, DeltaSignature* sig, Config* c
  return ok ? 0 : -1;
 }

-typedef bool (*file_send_fn)(File*, int, bool, int, bool);
+typedef bool (*file_send_fn)(File *, int, bool, int, bool);

-static int send_file_incremental(Client* client, File* file, Config* config, file_send_fn send_fn) {
-  DeltaSignature* sig = NULL;
+static int send_file_incremental(Client *client, File *file, Config *config,
+                                  file_send_fn send_fn) {
+  DeltaSignature *sig = NULL;
  int rc = incremental_check(client, file, &sig);
-  if (rc < 0) {
-    delta_signature_destroy(sig);
-    return -1;
-  }
-  if (rc == 1) {
-    delta_signature_destroy(sig);
-    return 1;
-  }
+  if (rc < 0) { delta_signature_destroy(sig); return -1; }
+  if (rc == 1) { delta_signature_destroy(sig); return 1; }
  if (rc == 2 && config->use_delta) {
    int drc = send_delta(client, file, sig, config);
    delta_signature_destroy(sig);
-    if (drc == 0)
-      return 0;
-    if (drc < 0)
-      return -1;
+    if (drc == 0) return 0;
+    if (drc < 0) return -1;
  } else {
    delta_signature_destroy(sig);
  }
@@ -125,37 +109,28 @@ static int send_file_incremental(Client* client, File* file, Config* config, fil
  return 0;
 }

-int send_chunk(Client* client, Chunk* chunk, Config* config) {
+int send_chunk(Client *client, Chunk *chunk, Config *config) {
  if (config->use_chunk_serialization) {
-    if (!send_status(client->file_descriptor, STATUS_CHUNK))
-      return -1;
-    Data* data;
+    if (!send_status(client->file_descriptor, STATUS_CHUNK)) return -1;
+    Data *data;
    if (config->use_compression) {
      data = chunk_compress(chunk, config->compression_level, config->use_metadata);
    } else {
      data = chunk_serialize(chunk, config->use_metadata);
    }
-    if (data == NULL)
-      return -1;
-    if (!send_data(client->file_descriptor, data)) {
-      data_destroy(data);
-      return -1;
-    }
+    if (data == NULL) return -1;
+    if (!send_data(client->file_descriptor, data)) { data_destroy(data); return -1; }
    data_destroy(data);
  } else if (config->use_sendfile && !config->use_compression) {
    for (int i = 0; i < chunk->element_count; i++) {
      if (config->use_incremental) {
        int rc = send_file_incremental(client, chunk->items[i], config,
-                                       (file_send_fn)file_send_sendfile);
-        if (rc == 1)
-          continue;
-        if (rc < 0)
-          return -1;
+                                        (file_send_fn)file_send_sendfile);
+        if (rc == 1) continue;
+        if (rc < 0) return -1;
      } else {
-        if (!send_status(client->file_descriptor, STATUS_NEXT))
-          return -1;
-        if (!file_send_sendfile(chunk->items[i], client->file_descriptor, config->use_metadata, 0,
-                                true))
+        if (!send_status(client->file_descriptor, STATUS_NEXT)) return -1;
+        if (!file_send_sendfile(chunk->items[i], client->file_descriptor, config->use_metadata, 0, true))
          return -1;
      }
    }
@@ -163,16 +138,15 @@ int send_chunk(Client* client, Chunk* chunk, Config* config) {
    for (int i = 0; i < chunk->element_count; i++) {
      if (config->use_incremental) {
        int rc = send_file_incremental(client, chunk->items[i], config,
-                                       (file_send_fn)file_send_single_calls);
-        if (rc == 1)
-          continue;
-        if (rc < 0)
-          return -1;
+                                        (file_send_fn)file_send_single_calls);
+        if (rc == 1) continue;
+        if (rc < 0) return -1;
      } else {
-        if (!send_status(client->file_descriptor, STATUS_NEXT))
-          return -1;
-        if (!file_send_single_calls(chunk->items[i], client->file_descriptor, config->use_metadata,
-                                    config->use_compression ? config->compression_level : 0, true))
+        if (!send_status(client->file_descriptor, STATUS_NEXT)) return -1;
+        if (!file_send_single_calls(chunk->items[i], client->file_descriptor,
+                               config->use_metadata,
+                               config->use_compression ? config->compression_level : 0,
+                               true))
          return -1;
      }
    }
@@ -180,9 +154,9 @@ int send_chunk(Client* client, Chunk* chunk, Config* config) {
  return 0;
 }

-static int send_chunks_multithreaded(void* pipeline_context) {
-  PipelineContextSender* context = (PipelineContextSender*)pipeline_context;
-  Client* client;
+static int send_chunks_multithreaded(void *pipeline_context) {
+  PipelineContextSender *context = (PipelineContextSender *)pipeline_context;
+  Client *client;
  if (context->config->transport == TRANSPORT_SSH) {
    if (context->config->use_sendfile) {
      fprintf(stderr, "Error: -f/--sendfile is not supported with SSH transport\n");
@@ -191,18 +165,18 @@ static int send_chunks_multithreaded(void* pipeline_context) {
    client = client_connect_ssh(context->config->ssh_destination, context->config->ssh_port);
  } else if (context->config->use_tls) {
    client = client_create();
-    if (!client || !client_connect_tls(client, server_host, server_port, context->config->tls_cert,
-                                       context->config->tls_key, context->config->tls_ca)) {
-      if (client)
-        client_delete(client);
+    if (!client || !client_connect_tls(client, server_host, server_port,
+                                        context->config->tls_cert,
+                                        context->config->tls_key,
+                                        context->config->tls_ca)) {
+      if (client) client_delete(client);
      fprintf(stderr, "Error: could not connect to server via TLS\n");
      return thrd_error;
    }
  } else {
    client = client_create();
    if (!client || !client_connect(client, server_host, server_port)) {
-      if (client)
-        client_delete(client);
+      if (client) client_delete(client);
      fprintf(stderr, "Error: could not connect to server\n");
      return thrd_error;
    }
@@ -214,15 +188,17 @@ static int send_chunks_multithreaded(void* pipeline_context) {
  }

  while (true) {
-    Chunk* current_chunk = queue_dequeue_multithreaded(
-        context->queue_loader, &context->mutex_loader, &context->condition_not_empty_loader,
+    Chunk *current_chunk = queue_dequeue_multithreaded(
+        context->queue_loader, &context->mutex_loader,
+        &context->condition_not_empty_loader,
        &context->condition_not_full_loader, &context->loader_done);
    if (current_chunk == NULL) {
      if (context->config->use_delete) {
        send_status(client->file_descriptor, STATUS_MANIFEST);
        send_int(client->file_descriptor, context->manifest->size);
        for (int i = 0; i < context->manifest->size; i++)
-          send_str(client->file_descriptor, (char*)context->manifest->items[i]);
+          send_str(client->file_descriptor,
+                   (char *)context->manifest->items[i]);
      }
      send_status(client->file_descriptor, STATUS_FINISHED);
      Status s;
@@ -241,29 +217,30 @@ static int send_chunks_multithreaded(void* pipeline_context) {
  }
 }

-static int scan_directory_multithreaded(void* pipeline_context) {
-  PipelineContextSender* context = (PipelineContextSender*)pipeline_context;
+static int scan_directory_multithreaded(void *pipeline_context) {
+  PipelineContextSender *context = (PipelineContextSender *)pipeline_context;
  mtx_lock(&context->mutex_scanner);
-  DirectoryScanner* scanner = directory_scanner_create(
-      context->config->send_directory, context->config->use_metadata, context->config->chunk_size,
-      context->config->exclude_patterns, context->config->exclude_count,
-      context->config->include_patterns, context->config->include_count, context->config->max_size,
+  DirectoryScanner *scanner = directory_scanner_create(
+      context->config->send_directory, context->config->use_metadata,
+      context->config->chunk_size, context->config->exclude_patterns,
+      context->config->exclude_count, context->config->include_patterns,
+      context->config->include_count, context->config->max_size,
      context->config->min_size);
  mtx_unlock(&context->mutex_scanner);

-  Chunk* current_chunk;
+  Chunk *current_chunk;
  while ((current_chunk = directory_scanner_next(scanner)) != NULL) {
    if (context->config->use_delete) {
      mtx_lock(&context->mutex_scanner);
      for (int i = 0; i < current_chunk->element_count; i++) {
-        const char* p = current_chunk->items[i]->path;
-        if (*p == '/')
-          p++;
+        const char *p = current_chunk->items[i]->path;
+        if (*p == '/') p++;
        array_list_add(context->manifest, str_dup(p));
      }
      mtx_unlock(&context->mutex_scanner);
    }
-    queue_enqueue_multithreaded(context->queue_scanner, current_chunk, &context->mutex_scanner,
+    queue_enqueue_multithreaded(context->queue_scanner, current_chunk,
+                                &context->mutex_scanner,
                                &context->condition_not_empty_scanner,
                                &context->condition_not_full_scanner);
  }
@@ -276,11 +253,12 @@ static int scan_directory_multithreaded(void* pipeline_context) {
  return thrd_success;
 }

-static int load_files_multithreaded(void* pipeline_context) {
-  PipelineContextSender* context = (PipelineContextSender*)pipeline_context;
+static int load_files_multithreaded(void *pipeline_context) {
+  PipelineContextSender *context = (PipelineContextSender *)pipeline_context;
  while (true) {
-    Chunk* chunk = queue_dequeue_multithreaded(
-        context->queue_scanner, &context->mutex_scanner, &context->condition_not_empty_scanner,
+    Chunk *chunk = queue_dequeue_multithreaded(
+        context->queue_scanner, &context->mutex_scanner,
+        &context->condition_not_empty_scanner,
        &context->condition_not_full_scanner, &context->scanner_done);
    if (chunk == NULL) {
      mtx_lock(&context->mutex_loader);
@@ -298,58 +276,60 @@ static int load_files_multithreaded(void* pipeline_context) {
        }
      }
    }
-    queue_enqueue_multithreaded(context->queue_loader, chunk, &context->mutex_loader,
+    queue_enqueue_multithreaded(context->queue_loader, chunk,
+                                &context->mutex_loader,
                                &context->condition_not_empty_loader,
                                &context->condition_not_full_loader);
  }
 }

-int send_files(Config* config) {
+int send_files(Config *config) {
  if (config->dry_run) {
-    DirectoryScanner* scanner = directory_scanner_create(
-        config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
-        config->exclude_count, config->include_patterns, config->include_count, config->max_size,
-        config->min_size);
-    Chunk* chunk;
+    DirectoryScanner *scanner = directory_scanner_create(
+        config->send_directory, config->use_metadata, config->chunk_size,
+        config->exclude_patterns, config->exclude_count,
+        config->include_patterns, config->include_count,
+        config->max_size, config->min_size);
+    Chunk *chunk;
    int file_count = 0;
    unsigned long long total_bytes = 0;
    printf("Dry run: files to be transferred\n");
    while ((chunk = directory_scanner_next(scanner)) != NULL) {
      for (int i = 0; i < chunk->element_count; i++) {
-        printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
+        printf("  %s (%zu bytes)\n", chunk->items[i]->path,
+               chunk->items[i]->data->size);
        total_bytes += chunk->items[i]->data->size;
        file_count++;
      }
      chunk_destroy(chunk);
    }
    directory_scanner_destroy(scanner);
-    printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
+    printf("Total: %d files, %.1f MB\n", file_count,
+           total_bytes / 1048576.0);
    return 0;
  }

-  Client* client;
+  Client *client;
  if (config->transport == TRANSPORT_SSH) {
    if (config->use_sendfile) {
      fprintf(stderr, "Error: -f/--sendfile is not supported with SSH transport\n");
      return 1;
    }
    client = client_connect_ssh(config->ssh_destination, config->ssh_port);
-    if (!client)
-      return 1;
+    if (!client) return 1;
  } else if (config->use_tls) {
    client = client_create();
-    if (!client || !client_connect_tls(client, server_host, server_port, config->tls_cert,
-                                       config->tls_key, config->tls_ca)) {
-      if (client)
-        client_delete(client);
+    if (!client || !client_connect_tls(client, server_host, server_port,
+                                        config->tls_cert, config->tls_key,
+                                        config->tls_ca)) {
+      if (client) client_delete(client);
      fprintf(stderr, "Error: could not connect to server via TLS\n");
      return 1;
    }
  } else {
    client = client_create();
    if (!client || !client_connect(client, server_host, server_port)) {
-      if (client)
-        client_delete(client);
+      if (client) client_delete(client);
      fprintf(stderr, "Error: could not connect to server\n");
      return 1;
    }
@@ -359,23 +339,23 @@ int send_files(Config* config) {
    client_delete(client);
    return 1;
  }
-  DirectoryScanner* scanner = directory_scanner_create(
-      config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
-      config->exclude_count, config->include_patterns, config->include_count, config->max_size,
-      config->min_size);
-  Chunk* current_chunk;
+  DirectoryScanner *scanner = directory_scanner_create(
+      config->send_directory, config->use_metadata, config->chunk_size,
+      config->exclude_patterns, config->exclude_count,
+      config->include_patterns, config->include_count,
+      config->max_size, config->min_size);
+  Chunk *current_chunk;
  unsigned long long total_bytes = 0;
  time_t last_progress = 0;
  time_t start = time(NULL);
-  ArrayList* manifest = config->use_delete ? array_list_create(free) : NULL;
+  ArrayList *manifest = config->use_delete ? array_list_create(free) : NULL;
  while ((current_chunk = directory_scanner_next(scanner)) != NULL) {
    unsigned long long chunk_bytes = 0;
    for (int i = 0; i < current_chunk->element_count; i++) {
      chunk_bytes += current_chunk->items[i]->data->size;
      if (manifest) {
-        const char* p = current_chunk->items[i]->path;
-        if (*p == '/')
-          p++;
+        const char *p = current_chunk->items[i]->path;
+        if (*p == '/') p++;
        array_list_add(manifest, str_dup(p));
      }
    }
@@ -409,7 +389,7 @@ int send_files(Config* config) {
    send_status(client->file_descriptor, STATUS_MANIFEST);
    send_int(client->file_descriptor, manifest->size);
    for (int i = 0; i < manifest->size; i++)
-      send_str(client->file_descriptor, (char*)manifest->items[i]);
+      send_str(client->file_descriptor, (char *)manifest->items[i]);
    array_list_delete(manifest);
  }
  send_status(client->file_descriptor, STATUS_FINISHED);
@@ -426,39 +406,41 @@ int send_files(Config* config) {
  return ok ? 0 : -1;
 }

-int send_files_multithreaded(Config* config) {
+int send_files_multithreaded(Config *config) {
  if (config->dry_run) {
-    DirectoryScanner* scanner = directory_scanner_create(
-        config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
-        config->exclude_count, config->include_patterns, config->include_count, config->max_size,
-        config->min_size);
-    Chunk* chunk;
+    DirectoryScanner *scanner = directory_scanner_create(
+        config->send_directory, config->use_metadata, config->chunk_size,
+        config->exclude_patterns, config->exclude_count,
+        config->include_patterns, config->include_count,
+        config->max_size, config->min_size);
+    Chunk *chunk;
    int file_count = 0;
    unsigned long long total_bytes = 0;
    printf("Dry run: files to be transferred\n");
    while ((chunk = directory_scanner_next(scanner)) != NULL) {
      for (int i = 0; i < chunk->element_count; i++) {
-        printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
+        printf("  %s (%zu bytes)\n", chunk->items[i]->path,
+               chunk->items[i]->data->size);
        total_bytes += chunk->items[i]->data->size;
        file_count++;
      }
      chunk_destroy(chunk);
    }
    directory_scanner_destroy(scanner);
-    printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
+    printf("Total: %d files, %.1f MB\n", file_count,
+           total_bytes / 1048576.0);
    return 0;
  }

-  Queue* q1 = queue_create(100, chunk_destroy);
-  Queue* q2 = queue_create(100, chunk_destroy);
+  Queue *q1 = queue_create(100, chunk_destroy);
+  Queue *q2 = queue_create(100, chunk_destroy);
  if (!q1 || !q2) {
-    if (q1)
-      queue_destroy(q1);
-    if (q2)
-      queue_destroy(q2);
+    if (q1) queue_destroy(q1);
+    if (q2) queue_destroy(q2);
    return 1;
  }
-  PipelineContextSender* context = pipeline_context_sender_create(config, q1, q2);
+  PipelineContextSender *context =
+      pipeline_context_sender_create(config, q1, q2);
  if (!context) {
    queue_destroy(q1);
    queue_destroy(q2);
@@ -468,9 +450,11 @@ int send_files_multithreaded(Config* config) {
    context->manifest = array_list_create(free);

  thrd_t scanner, loader, sender;
-  if (thrd_create(&scanner, scan_directory_multithreaded, context) != thrd_success ||
+  if (thrd_create(&scanner, scan_directory_multithreaded, context) !=
+          thrd_success ||
      thrd_create(&loader, load_files_multithreaded, context) != thrd_success ||
-      thrd_create(&sender, send_chunks_multithreaded, context) != thrd_success) {
+      thrd_create(&sender, send_chunks_multithreaded, context) !=
+          thrd_success) {
    perror("Error creating threads.\n");
    pipeline_context_sender_destroy(context);
    return 1;
@@ -5,11 +5,11 @@
 #include "config.h"
 #include "transport_tcp.h"

-extern char* server_host;
+extern char *server_host;
 extern int server_port;

-int send_chunk(Client* client, Chunk* chunk, Config* config);
-int send_files(Config* config);
-int send_files_multithreaded(Config* config);
+int send_chunk(Client *client, Chunk *chunk, Config *config);
+int send_files(Config *config);
+int send_files_multithreaded(Config *config);

 #endif
@@ -11,14 +11,8 @@
 #include <sys/stat.h>
 #include <unistd.h>

-DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metadata,
-                                           unsigned long long chunk_size, char** exclude_patterns,
-                                           int exclude_count, char** include_patterns,
-                                           int include_count, unsigned long long max_size,
-                                           unsigned long long min_size) {
-  DirectoryScanner* scanner = malloc(sizeof(DirectoryScanner));
-  if (scanner == NULL)
-    return NULL;
+DirectoryScanner *directory_scanner_create(char *root_directory, bool use_metadata, unsigned long long chunk_size, char **exclude_patterns, int exclude_count, char **include_patterns, int include_count, unsigned long long max_size, unsigned long long min_size) {
+  DirectoryScanner *scanner = malloc(sizeof(DirectoryScanner));
  scanner->directories = queue_create(100, free);
  scanner->current_dir = NULL;
  scanner->current_path = NULL;
@@ -34,7 +28,7 @@ DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metada
  return scanner;
 }

-void directory_scanner_destroy(DirectoryScanner* scanner) {
+void directory_scanner_destroy(DirectoryScanner *scanner) {
  if (scanner == NULL)
    return;
  if (scanner->current_dir) {
@@ -46,16 +40,16 @@ void directory_scanner_destroy(DirectoryScanner* scanner) {
  free(scanner);
 }

-static Chunk* chunk_data_to_chunk(ArrayList* chunk_data) {
-  void** chunk_items = array_list_to_array(chunk_data);
-  Chunk* chunk = chunk_create((File**)chunk_items, chunk_data->size);
+static Chunk *chunk_data_to_chunk(ArrayList *chunk_data) {
+  void **chunk_items = array_list_to_array(chunk_data);
+  Chunk *chunk = chunk_create((File **)chunk_items, chunk_data->size);
  free(chunk_items);
  chunk_data->item_destroyer = NULL;
  array_list_delete(chunk_data);
  return chunk;
 }

-static int open_next_directory(DirectoryScanner* scanner) {
+static int open_next_directory(DirectoryScanner *scanner) {
  if (scanner->current_dir) {
    closedir(scanner->current_dir);
    scanner->current_dir = NULL;
@@ -65,7 +59,7 @@ static int open_next_directory(DirectoryScanner* scanner) {
  if (queue_is_empty(scanner->directories))
    return 0;

-  scanner->current_path = (char*)queue_dequeue(scanner->directories);
+  scanner->current_path = (char *)queue_dequeue(scanner->directories);
  scanner->current_dir = opendir(scanner->current_path);
  if (scanner->current_dir == NULL) {
    perror("Could not open directory");
@@ -76,8 +70,8 @@ static int open_next_directory(DirectoryScanner* scanner) {
  return 1;
 }

-Chunk* directory_scanner_next(DirectoryScanner* scanner) {
-  ArrayList* chunk_data = array_list_create(file_destroy);
+Chunk *directory_scanner_next(DirectoryScanner *scanner) {
+  ArrayList *chunk_data = array_list_create(file_destroy);
  unsigned long long chunk_data_size = 0;

  while (1) {
@@ -86,7 +80,7 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {
        break;
    }

-    struct dirent* entry = readdir(scanner->current_dir);
+    struct dirent *entry = readdir(scanner->current_dir);
    if (entry == NULL) {
      closedir(scanner->current_dir);
      scanner->current_dir = NULL;
@@ -98,7 +92,7 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {
    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
      continue;

-    char* cur_path = path_cat(scanner->current_path, entry->d_name);
+    char *cur_path = path_cat(scanner->current_path, entry->d_name);
    struct stat stats;
    if (stat(cur_path, &stats) != 0) {
      free(cur_path);
@@ -106,7 +100,7 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {
    }

    if (S_ISDIR(stats.st_mode)) {
-      queue_enqueue(scanner->directories, (void*)cur_path);
+      queue_enqueue(scanner->directories, (void *)cur_path);
    } else {
      bool excluded = false;
      for (int i = 0; i < scanner->exclude_count; i++) {
@@ -140,7 +134,7 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {
        continue;
      }

-      File* file = file_create(cur_path);
+      File *file = file_create(cur_path);
      if (file == NULL) {
        free(cur_path);
        continue;
@@ -160,6 +154,7 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {

  if (chunk_data->size > 0)
    return chunk_data_to_chunk(chunk_data);
+  chunk_data->item_destroyer = NULL;
  array_list_delete(chunk_data);
  return NULL;
 }
@@ -7,25 +7,21 @@
 #include <stdbool.h>

 typedef struct {
-  Queue* directories;
-  DIR* current_dir;
-  char* current_path;
+  Queue *directories;
+  DIR *current_dir;
+  char *current_path;
  bool use_metadata;
  unsigned long long chunk_size;
-  char** exclude_patterns;
+  char **exclude_patterns;
  int exclude_count;
-  char** include_patterns;
+  char **include_patterns;
  int include_count;
  unsigned long long max_size;
  unsigned long long min_size;
 } DirectoryScanner;

-DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metadata,
-                                           unsigned long long chunk_size, char** exclude_patterns,
-                                           int exclude_count, char** include_patterns,
-                                           int include_count, unsigned long long max_size,
-                                           unsigned long long min_size);
-Chunk* directory_scanner_next(DirectoryScanner* scanner);
-void directory_scanner_destroy(DirectoryScanner* scanner);
+DirectoryScanner *directory_scanner_create(char *root_directory, bool use_metadata, unsigned long long chunk_size, char **exclude_patterns, int exclude_count, char **include_patterns, int include_count, unsigned long long max_size, unsigned long long min_size);
+Chunk *directory_scanner_next(DirectoryScanner *scanner);
+void directory_scanner_destroy(DirectoryScanner *scanner);

 #endif
@@ -16,24 +16,21 @@
 #include <stdlib.h>
 #include <string.h>

-int receive_files(Config* config, int fd) {
+int receive_files(Config *config, int fd) {
  Status status;
-  if (!receive_status(fd, &status))
-    return -1;
+  if (!receive_status(fd, &status)) return -1;

  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
    if (status == STATUS_CHECK) {
      bool skipped;
-      File* file = receive_incremental_check(fd, config, &skipped);
-      if (skipped)
-        goto next;
-      if (file == NULL && !skipped)
-        return -1;
+      File *file = receive_incremental_check(fd, config, &skipped);
+      if (skipped) goto next;
+      if (file == NULL && !skipped) return -1;
      if (config->save_to_disk)
        file_save_to_disk(config->receive_root_directory, file);
      file_destroy(file);
    } else if (status == STATUS_CHUNK) {
-      Chunk* chunk = receive_chunk_data(fd, config);
+      Chunk *chunk = receive_chunk_data(fd, config);
      if (chunk == NULL) {
        send_status(fd, STATUS_ERROR);
        return -1;
@@ -44,7 +41,7 @@ int receive_files(Config* config, int fd) {
      }
      chunk_destroy(chunk);
    } else {
-      File* file = file_receive(config, fd);
+      File *file = file_receive(config, fd);
      if (file == NULL) {
        log_message(LOG_LEVEL_ERROR, "Failed to receive file");
        send_status(fd, STATUS_ERROR);
@@ -62,8 +59,7 @@ int receive_files(Config* config, int fd) {
  }

  if (status == STATUS_MANIFEST) {
-    if (receive_manifest(fd, config, &status) != 0)
-      return -1;
+    if (receive_manifest(fd, config, &status) != 0) return -1;
  }
  if (status != STATUS_FINISHED) {
    log_message(LOG_LEVEL_ERROR, "Did not receive FINISHED Status");
@@ -75,20 +71,21 @@ int receive_files(Config* config, int fd) {
 }

 void handler(int file_descriptor) {
-  Config* config = config_receive(file_descriptor);
+  Config *config = config_receive(file_descriptor);
  if (config == NULL) {
    log_message(LOG_LEVEL_ERROR, "Failed to receive config");
    close(file_descriptor);
    return;
  }
  if (config->use_multithreading) {
-    Queue* q = queue_create(100, file_destroy);
+    Queue *q = queue_create(100, file_destroy);
    if (q == NULL) {
      config_delete(config);
      close(file_descriptor);
      return;
    }
-    PipelineContextReceiver* context = pipeline_context_receiver_create(config, q, file_descriptor);
+    PipelineContextReceiver *context = pipeline_context_receiver_create(
+        config, q, file_descriptor);
    if (context == NULL) {
      queue_destroy(q);
      config_delete(config);
@@ -112,7 +109,7 @@ void handler(int file_descriptor) {
  close(file_descriptor);
 }

-static Server* g_server = NULL;
+static Server *g_server = NULL;

 static void cleanup(int sig) {
  (void)sig;
@@ -137,11 +134,11 @@ static void print_server_usage(void) {
  printf("  --help              Show this help\n");
 }

-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
  bool use_tls = false;
-  char* tls_cert = NULL;
-  char* tls_key = NULL;
-  char* tls_ca = NULL;
+  char *tls_cert = NULL;
+  char *tls_key = NULL;
+  char *tls_ca = NULL;
  int port = 8080;

  signal(SIGPIPE, SIG_IGN);
@@ -164,7 +161,7 @@ int main(int argc, char* argv[]) {
    } else if (strcmp(argv[i], "--ca") == 0 && i + 1 < argc) {
      tls_ca = argv[++i];
    } else if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
-      char* end;
+      char *end;
      long p = strtol(argv[++i], &end, 10);
      if (*end || p <= 0 || p > 65535) {
        fprintf(stderr, "Error: invalid port '%s' (must be 1-65535)\n", argv[i]);
@@ -3,14 +3,14 @@
 #include <stdlib.h>
 #include <string.h>

-ArrayList* array_list_create(void (*item_destroyer)(void* item)) {
-  ArrayList* list = (ArrayList*)malloc(sizeof(ArrayList));
+ArrayList *array_list_create(void (*item_destroyer)(void *item)) {
+  ArrayList *list = (ArrayList *)malloc(sizeof(ArrayList));
  if (list == NULL) {
    perror("ERROR: Could not allocate memory for array list struct");
    return NULL;
  }

-  list->items = malloc(INITIAL_ARRAY_SIZE * sizeof(void*));
+  list->items = malloc(INITIAL_ARRAY_SIZE * sizeof(void *));
  if (list->items == NULL) {
    free(list);
    return NULL;
@@ -21,7 +21,7 @@ ArrayList* array_list_create(void (*item_destroyer)(void* item)) {
  return list;
 }

-void array_list_delete(ArrayList* array_list) {
+void array_list_delete(ArrayList *array_list) {
  if (array_list == NULL)
    return;
  if (array_list->item_destroyer != NULL) {
@@ -34,13 +34,12 @@ void array_list_delete(ArrayList* array_list) {
  free(array_list);
 }

-bool array_list_extend(ArrayList* array_list) {
-  if (array_list == NULL)
-    return false;
+bool array_list_extend(ArrayList *array_list) {
+  if (array_list == NULL) return false;
  int new_capacity = array_list->capacity * 2;
  if (new_capacity == 0)
    new_capacity = INITIAL_ARRAY_SIZE;
-  void* new_items = realloc(array_list->items, new_capacity * sizeof(void*));
+  void *new_items = realloc(array_list->items, new_capacity * sizeof(void *));
  if (new_items == NULL) {
    perror("ERROR: Could not reallocate memory for array list items");
    return false;
@@ -50,9 +49,8 @@ bool array_list_extend(ArrayList* array_list) {
  return true;
 }

-bool array_list_add(ArrayList* array_list, void* item) {
-  if (array_list == NULL)
-    return false;
+bool array_list_add(ArrayList *array_list, void *item) {
+  if (array_list == NULL) return false;
  if (array_list->capacity == array_list->size) {
    if (!array_list_extend(array_list))
      return false;
@@ -62,15 +60,15 @@ bool array_list_add(ArrayList* array_list, void* item) {
  return true;
 }

-void** array_list_to_array(const ArrayList* array_list) {
+void **array_list_to_array(ArrayList *array_list) {
  if (array_list == NULL) {
    return NULL;
  }
-  void** array = malloc(array_list->size * sizeof(void*));
+  void **array = malloc(array_list->size * sizeof(void *));
  if (array == NULL) {
    perror("Could not malloc space for array from array list!");
    return NULL;
  }
-  memcpy(array, array_list->items, array_list->size * sizeof(void*));
+  memcpy(array, array_list->items, array_list->size * sizeof(void *));
  return array;
 }
@@ -6,16 +6,16 @@
 #define INITIAL_ARRAY_SIZE 100

 typedef struct ArrayList {
-  void** items;
+  void **items;
  int size;
  int capacity;
-  void (*item_destroyer)(void* item);
+  void (*item_destroyer)(void *item);
 } ArrayList;

-ArrayList* array_list_create(void (*item_destroyer)(void* item));
-void array_list_delete(ArrayList* array_list);
-bool array_list_extend(ArrayList* array_list);
-bool array_list_add(ArrayList* array_list, void* item);
-void** array_list_to_array(const ArrayList* array_list);
+ArrayList *array_list_create(void (*item_destroyer)(void *item));
+void array_list_delete(ArrayList *array_list);
+bool array_list_extend(ArrayList *array_list);
+bool array_list_add(ArrayList *array_list, void *item);
+void **array_list_to_array(ArrayList *array_list);

 #endif
@@ -12,14 +12,14 @@
 #include "metadata.h"
 #include "protocol.h"

-Chunk* chunk_create(File** items, int element_count) {
-  Chunk* chunk = (Chunk*)malloc(sizeof(Chunk));
+Chunk *chunk_create(File **items, int element_count) {
+  Chunk *chunk = (Chunk *)malloc(sizeof(Chunk));
  if (chunk == NULL) {
    perror("ERROR: Could not allocate memory for chunk structure");
    return NULL;
  }

-  chunk->items = (File**)malloc(element_count * sizeof(File*));
+  chunk->items = (File **)malloc(element_count * sizeof(File *));
  if (chunk->items == NULL) {
    free(chunk);
    return NULL;
@@ -32,11 +32,11 @@ Chunk* chunk_create(File** items, int element_count) {
  return chunk;
 }

-void chunk_destroy(void* item) {
+void chunk_destroy(void *item) {
  if (item == NULL) {
    return;
  }
-  Chunk* chunk = (Chunk*)item;
+  Chunk *chunk = (Chunk *)item;
  for (int i = 0; i < chunk->element_count; ++i) {
    if (chunk->items[i] != NULL) {
      file_destroy(chunk->items[i]);
@@ -46,25 +46,26 @@ void chunk_destroy(void* item) {
  free(chunk);
 }

-static unsigned long long per_file_serialize_size(File* file, bool use_metadata) {
+static unsigned long long per_file_serialize_size(File *file, bool use_metadata) {
  return sizeof(size_t) + strlen(file->path) +
         (use_metadata ? sizeof(int) + (file->metadata ? FILE_METADATA_WIRE_SIZE : 0) : 0) +
         sizeof(size_t) + file->data->size;
 }

-Data* chunk_serialize(Chunk* chunk, bool use_metadata) {
+Data *chunk_serialize(Chunk *chunk, bool use_metadata) {
  unsigned long long data_size = 0;
  for (int i = 0; i < chunk->element_count; i++) {
    data_size += per_file_serialize_size(chunk->items[i], use_metadata);
  }
-  Data* data = data_create_empty(data_size);
+  Data *data = data_create_empty(data_size);
  if (data == NULL) {
-    log_message(LOG_LEVEL_ERROR, "Could not allocate memory for chunk serialization");
+    log_message(LOG_LEVEL_ERROR,
+                "Could not allocate memory for chunk serialization");
    return NULL;
  }
-  char* data_pointer = data->data;
+  char *data_pointer = data->data;
  for (int i = 0; i < chunk->element_count; i++) {
-    File* file = chunk->items[i];
+    File *file = chunk->items[i];
    size_t path_len = strlen(file->path);
    memcpy(data_pointer, &path_len, sizeof(size_t));
    data_pointer += sizeof(size_t);
@@ -83,9 +84,9 @@ Data* chunk_serialize(Chunk* chunk, bool use_metadata) {
  return data;
 }

-Chunk* chunk_deserialize(Data* data, bool use_metadata) {
-  ArrayList* files = array_list_create(file_destroy);
-  char* data_pointer = data->data;
+Chunk *chunk_deserialize(Data *data, bool use_metadata) {
+  ArrayList *files = array_list_create(file_destroy);
+  char *data_pointer = data->data;
  size_t remaining_size = data->size;

  while (remaining_size > 0) {
@@ -95,7 +96,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
      return NULL;
    }

-    size_t path_len = *(size_t*)data_pointer;
+    size_t path_len = *(size_t *)data_pointer;
    data_pointer += sizeof(size_t);
    remaining_size -= sizeof(size_t);

@@ -105,7 +106,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
      return NULL;
    }

-    char* path = malloc(path_len + 1);
+    char *path = malloc(path_len + 1);
    if (path == NULL) {
      perror("Could not allocate memory for file path");
      array_list_delete(files);
@@ -116,7 +117,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
    data_pointer += path_len;
    remaining_size -= path_len;

-    File* file = file_create(path);
+    File *file = file_create(path);
    free(path);

    if (use_metadata) {
@@ -132,7 +133,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
      return NULL;
    }

-    size_t file_data_size = *(size_t*)data_pointer;
+    size_t file_data_size = *(size_t *)data_pointer;
    data_pointer += sizeof(size_t);
    remaining_size -= sizeof(size_t);

@@ -142,7 +143,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
      return NULL;
    }

-    void* file_data = malloc(file_data_size);
+    void *file_data = malloc(file_data_size);
    if (file_data == NULL) {
      perror("Could not allocate memory for file data");
      array_list_delete(files);
@@ -157,8 +158,8 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
    array_list_add(files, file);
  }

-  File** file_array = (File**)array_list_to_array(files);
-  Chunk* chunk = chunk_create(file_array, files->size);
+  File **file_array = (File **)array_list_to_array(files);
+  Chunk *chunk = chunk_create(file_array, files->size);

  free(file_array);
  files->item_destroyer = NULL;
@@ -167,26 +168,24 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
  return chunk;
 }

-Data* chunk_compress(Chunk* chunk, int compression_level, bool use_metadata) {
+Data *chunk_compress(Chunk *chunk, int compression_level, bool use_metadata) {
  log_message(LOG_LEVEL_DEBUG, "Starting to compress chunk");
-  Data* serialized = chunk_serialize(chunk, use_metadata);
-  if (serialized == NULL)
-    return NULL;
-  Data* compressed = data_compress(serialized, compression_level);
+  Data *serialized = chunk_serialize(chunk, use_metadata);
+  if (serialized == NULL) return NULL;
+  Data *compressed = data_compress(serialized, compression_level);
  data_destroy(serialized);
-  if (compressed == NULL)
-    return NULL;
+  if (compressed == NULL) return NULL;
  log_message(LOG_LEVEL_DEBUG, "Chunk successfully compressed");
  return compressed;
 }

-Chunk* receive_chunk_data(int fd, const Config* config) {
-  Data* chunk_data = receive_data(fd);
+Chunk *receive_chunk_data(int fd, Config *config) {
+  Data *chunk_data = receive_data(fd);
  if (chunk_data == NULL) {
    log_message(LOG_LEVEL_ERROR, "Failed to receive chunk data");
    return NULL;
  }
-  Data* data_to_process = chunk_data;
+  Data *data_to_process = chunk_data;
  if (config->use_compression) {
    data_to_process = data_decompress(chunk_data);
    data_destroy(chunk_data);
@@ -195,9 +194,12 @@ Chunk* receive_chunk_data(int fd, const Config* config) {
      return NULL;
    }
  }
-  Chunk* chunk = chunk_deserialize(data_to_process, config->use_metadata);
+  Chunk *chunk = chunk_deserialize(data_to_process, config->use_metadata);
  data_destroy(data_to_process);
  if (chunk == NULL)
    log_message(LOG_LEVEL_ERROR, "Failed to deserialize chunk, skipping");
  return chunk;
 }
+
+
+
@@ -10,15 +10,15 @@
 #define DESIRED_CHUNK_SIZE (10 * 1024 * 1024)

 typedef struct {
-  File** items;
+  File **items;
  int element_count;
 } Chunk;

-Chunk* chunk_create(File** items, int element_count);
-void chunk_destroy(void* chunk);
-Data* chunk_serialize(Chunk* chunk, bool use_metadata);
-Chunk* chunk_deserialize(Data* data, bool use_metadata);
-Data* chunk_compress(Chunk* chunk, int compression_level, bool use_metadata);
-Chunk* receive_chunk_data(int fd, const Config* config);
+Chunk *chunk_create(File **items, int element_count);
+void chunk_destroy(void *chunk);
+Data *chunk_serialize(Chunk *chunk, bool use_metadata);
+Chunk *chunk_deserialize(Data *data, bool use_metadata);
+Data *chunk_compress(Chunk *chunk, int compression_level, bool use_metadata);
+Chunk *receive_chunk_data(int fd, Config *config);

 #endif
@@ -6,15 +6,13 @@

 #define INITIAL_DECOMPRESS_BUF_SIZE (1024 * 1024)

-Data* data_compress(Data* data_to_compress, int compression_level) {
-  (void)compression_level;
+Data *data_compress(Data *data_to_compress, int compression_level) {
  log_message(LOG_LEVEL_DEBUG, "Starting to compress data");
  size_t dst_size = ZSTD_compressBound(data_to_compress->size);
-  Data* compressed_data = data_create_empty(dst_size);
-  if (compressed_data == NULL)
-    return NULL;
+  Data *compressed_data = data_create_empty(dst_size);
+  if (compressed_data == NULL) return NULL;

-  ZSTD_CCtx* cctx = ZSTD_createCCtx();
+  ZSTD_CCtx *cctx = ZSTD_createCCtx();
  if (!cctx) {
    log_message(LOG_LEVEL_ERROR, "Failed to create ZSTD compression context");
    data_destroy(compressed_data);
@@ -28,7 +26,8 @@ Data* data_compress(Data* data_to_compress, int compression_level) {
  do {
    ret = ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);
    if (ZSTD_isError(ret)) {
-      log_message(LOG_LEVEL_ERROR, "Compression failed: %s", ZSTD_getErrorName(ret));
+      log_message(LOG_LEVEL_ERROR, "Compression failed: %s",
+                  ZSTD_getErrorName(ret));
      ZSTD_freeCCtx(cctx);
      data_destroy(compressed_data);
      return NULL;
@@ -43,25 +42,27 @@ Data* data_compress(Data* data_to_compress, int compression_level) {
  return compressed_data;
 }

-Data* data_decompress(Data* compressed_data) {
+Data *data_decompress(Data *compressed_data) {
  log_message(LOG_LEVEL_DEBUG, "Start to decompress data");
-  unsigned long long dst_size =
-      ZSTD_getFrameContentSize(compressed_data->data, compressed_data->size);
+  unsigned long long dst_size = ZSTD_getFrameContentSize(
+      compressed_data->data, compressed_data->size);
  if (ZSTD_isError(dst_size)) {
    log_message(LOG_LEVEL_ERROR, "Failed to get decompressed size: %s",
                ZSTD_getErrorName(dst_size));
    return NULL;
  }

-  ZSTD_DCtx* dctx = ZSTD_createDCtx();
+  ZSTD_DCtx *dctx = ZSTD_createDCtx();
  if (!dctx) {
-    log_message(LOG_LEVEL_ERROR, "Failed to create ZSTD decompression context");
+    log_message(LOG_LEVEL_ERROR,
+                "Failed to create ZSTD decompression context");
    return NULL;
  }

-  size_t buf_size =
-      (!ZSTD_isError(dst_size) && dst_size > 0) ? (size_t)dst_size : INITIAL_DECOMPRESS_BUF_SIZE;
-  Data* uncompressed_data = data_create_empty(buf_size);
+  size_t buf_size = (!ZSTD_isError(dst_size) && dst_size > 0)
+                        ? (size_t)dst_size
+                        : INITIAL_DECOMPRESS_BUF_SIZE;
+  Data *uncompressed_data = data_create_empty(buf_size);
  if (!uncompressed_data) {
    log_message(LOG_LEVEL_ERROR, "Failed to allocate decompression buffer");
    ZSTD_freeDCtx(dctx);
@@ -75,14 +76,15 @@ Data* data_decompress(Data* compressed_data) {
  do {
    ret = ZSTD_decompressStream(dctx, &output, &input);
    if (ZSTD_isError(ret)) {
-      log_message(LOG_LEVEL_ERROR, "Decompression failed: %s", ZSTD_getErrorName(ret));
+      log_message(LOG_LEVEL_ERROR, "Decompression failed: %s",
+                  ZSTD_getErrorName(ret));
      ZSTD_freeDCtx(dctx);
      data_destroy(uncompressed_data);
      return NULL;
    }
    if (ret > 0 && output.pos == output.size) {
      buf_size *= 2;
-      void* new_data = realloc(uncompressed_data->data, buf_size);
+      void *new_data = realloc(uncompressed_data->data, buf_size);
      if (!new_data) {
        log_message(LOG_LEVEL_ERROR, "Failed to grow decompression buffer");
        ZSTD_freeDCtx(dctx);
@@ -3,7 +3,7 @@

 #include "data.h"

-Data* data_compress(Data* data_to_compress, int compression_level);
-Data* data_decompress(Data* compressed_data);
+Data *data_compress(Data *data_to_compress, int compression_level);
+Data *data_decompress(Data *compressed_data);

 #endif
@@ -8,12 +8,14 @@
 #include <stdlib.h>
 #include <string.h>

-Config* config_create(char* version, char* send_directory, char* receive_directory,
-                      bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
-                      bool use_compression, bool use_metadata, int compression_level,
-                      bool use_sendfile, unsigned long long chunk_size) {
+Config *config_create(char *version, char *send_directory,
+                      char *receive_directory, bool save_to_disk,
+                      bool use_multithreading, bool use_chunk_serialization,
+                       bool use_compression, bool use_metadata,
+                       int compression_level, bool use_sendfile,
+                       unsigned long long chunk_size) {

-  Config* config = malloc(sizeof(Config));
+  Config *config = malloc(sizeof(Config));
  config->version = version;
  config->send_directory = send_directory;
  config->receive_root_directory = receive_directory;
@@ -48,33 +50,28 @@ Config* config_create(char* version, char* send_directory, char* receive_directo
  return config;
 }

-bool is_remote_dest(const char* s) {
-  if (s == NULL)
-    return false;
-  const char* colon = strchr(s, ':');
-  if (colon == NULL)
-    return false;
-  if (colon == s)
-    return false;
-  for (const char* p = s; p < colon; p++) {
-    if (*p == '/')
-      return false;
+bool is_remote_dest(const char *s) {
+  if (s == NULL) return false;
+  const char *colon = strchr(s, ':');
+  if (colon == NULL) return false;
+  if (colon == s) return false;
+  for (const char *p = s; p < colon; p++) {
+    if (*p == '/') return false;
  }
  return true;
 }

-void config_parse_ssh_dest(Config* config) {
-  if (!is_remote_dest(config->receive_root_directory))
-    return;
+void config_parse_ssh_dest(Config *config) {
+  if (!is_remote_dest(config->receive_root_directory)) return;
  config->transport = TRANSPORT_SSH;
  config->ssh_destination = str_dup(config->receive_root_directory);
-  const char* colon = strchr(config->receive_root_directory, ':');
-  char* path = str_dup(colon + 1);
+  char *colon = strchr(config->receive_root_directory, ':');
+  char *path = str_dup(colon + 1);
  free(config->receive_root_directory);
  config->receive_root_directory = path;
 }

-void config_delete(Config* config) {
+void config_delete(Config *config) {
  free(config->version);
  free(config->send_directory);
  free(config->receive_root_directory);
@@ -91,42 +88,25 @@ void config_delete(Config* config) {
  free(config);
 }

-bool config_send(int file_descriptor, const Config* config) {
-  if (!send_str(file_descriptor, config->version))
-    return false;
-  if (!send_str(file_descriptor, config->send_directory))
-    return false;
-  if (!send_str(file_descriptor, config->receive_root_directory))
-    return false;
-  if (!send_int(file_descriptor, config->save_to_disk))
-    return false;
-  if (!send_int(file_descriptor, config->use_multithreading))
-    return false;
-  if (!send_int(file_descriptor, config->use_chunk_serialization))
-    return false;
-  if (!send_int(file_descriptor, config->use_compression))
-    return false;
-  if (!send_int(file_descriptor, config->use_metadata))
-    return false;
-  if (!send_int(file_descriptor, config->compression_level))
-    return false;
-  if (!send_int(file_descriptor, (int)config->chunk_size))
-    return false;
-  if (!send_int(file_descriptor, config->use_sendfile))
-    return false;
-  if (!send_int(file_descriptor, config->use_delete))
-    return false;
-  if (!send_int(file_descriptor, config->use_incremental))
-    return false;
-  if (!send_int(file_descriptor, config->use_delta))
-    return false;
-  if (!send_int(file_descriptor, (int)config->delta_block_size))
-    return false;
-  if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
-    return false;
+bool config_send(int file_descriptor, Config *config) {
+  if (!send_str(file_descriptor, config->version)) return false;
+  if (!send_str(file_descriptor, config->send_directory)) return false;
+  if (!send_str(file_descriptor, config->receive_root_directory)) return false;
+  if (!send_int(file_descriptor, config->save_to_disk)) return false;
+  if (!send_int(file_descriptor, config->use_multithreading)) return false;
+  if (!send_int(file_descriptor, config->use_chunk_serialization)) return false;
+  if (!send_int(file_descriptor, config->use_compression)) return false;
+  if (!send_int(file_descriptor, config->use_metadata)) return false;
+  if (!send_int(file_descriptor, config->compression_level)) return false;
+  if (!send_int(file_descriptor, (int)config->chunk_size)) return false;
+  if (!send_int(file_descriptor, config->use_sendfile)) return false;
+  if (!send_int(file_descriptor, config->use_delete)) return false;
+  if (!send_int(file_descriptor, config->use_incremental)) return false;
+  if (!send_int(file_descriptor, config->use_delta)) return false;
+  if (!send_int(file_descriptor, (int)config->delta_block_size)) return false;
+  if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long))) return false;
  Status status;
-  if (!receive_status(file_descriptor, &status))
-    return false;
+  if (!receive_status(file_descriptor, &status)) return false;
  if (status != STATUS_OK) {
    log_message(LOG_LEVEL_ERROR, "Error transmitting config");
    return false;
@@ -134,75 +114,49 @@ bool config_send(int file_descriptor, const Config* config) {
  return true;
 }

-Config* config_receive(int file_descriptor) {
-  Config* config = (Config*)malloc(sizeof(Config));
-  if (config == NULL)
-    return NULL;
+Config *config_receive(int file_descriptor) {
+  Config *config = (Config *)malloc(sizeof(Config));
+  if (config == NULL) return NULL;
  config->version = receive_str(file_descriptor);
-  if (!config->version) {
-    free(config);
-    return NULL;
-  }
+  if (!config->version) { free(config); return NULL; }
  if (strcmp(config->version, PROTOCOL_VERSION) != 0) {
-    fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n", config->version,
-            PROTOCOL_VERSION);
+    fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n",
+            config->version, PROTOCOL_VERSION);
    free(config->version);
    free(config);
    send_status(file_descriptor, STATUS_ERROR);
    return NULL;
  }
  config->send_directory = receive_str(file_descriptor);
-  if (!config->send_directory) {
-    free(config->version);
-    free(config);
-    return NULL;
-  }
+  if (!config->send_directory) { free(config->version); free(config); return NULL; }
  config->receive_root_directory = receive_str(file_descriptor);
-  if (!config->receive_root_directory) {
-    free(config->version);
-    free(config->send_directory);
-    free(config);
-    return NULL;
-  }
+  if (!config->receive_root_directory) { free(config->version); free(config->send_directory); free(config); return NULL; }
  int tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->save_to_disk = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_multithreading = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_chunk_serialization = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_compression = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_metadata = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->compression_level = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->chunk_size = (unsigned long long)tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_sendfile = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_delete = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_incremental = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->use_delta = tmp;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
+  if (!receive_int(file_descriptor, &tmp)) goto error;
  config->delta_block_size = (uint32_t)tmp;
-  if (!receive_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
-    goto error;
+  if (!receive_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long))) goto error;
  config->show_progress = false;
  config->dry_run = false;
  config->ssh_port = 22;
@@ -218,8 +172,7 @@ Config* config_receive(int file_descriptor) {
  config->tls_cert = NULL;
  config->tls_key = NULL;
  config->tls_ca = NULL;
-  if (!send_status(file_descriptor, STATUS_OK))
-    goto error;
+  if (!send_status(file_descriptor, STATUS_OK)) goto error;
  return config;

 error:
@@ -4,12 +4,15 @@
 #include <stdbool.h>
 #include <stdint.h>

-typedef enum { TRANSPORT_TCP, TRANSPORT_SSH } TransportType;
+typedef enum {
+  TRANSPORT_TCP,
+  TRANSPORT_SSH
+} TransportType;

 typedef struct Config {
-  char* version;
-  char* send_directory;
-  char* receive_root_directory;
+  char *version;
+  char *send_directory;
+  char *receive_root_directory;
  bool save_to_disk;
  bool use_multithreading;
  bool use_chunk_serialization;
@@ -23,10 +26,10 @@ typedef struct Config {
  unsigned long long chunk_size;
  int ssh_port;
  TransportType transport;
-  char* ssh_destination;
-  char** exclude_patterns;
+  char *ssh_destination;
+  char **exclude_patterns;
  int exclude_count;
-  char** include_patterns;
+  char **include_patterns;
  int include_count;
  unsigned long long max_size;
  unsigned long long min_size;
@@ -35,22 +38,24 @@ typedef struct Config {
  uint32_t delta_block_size;
  unsigned long long delta_max_file_size;
  bool use_tls;
-  char* tls_cert;
-  char* tls_key;
-  char* tls_ca;
+  char *tls_cert;
+  char *tls_key;
+  char *tls_ca;
 } Config;

 #define PROTOCOL_VERSION "1.2.0"
 #define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)

-Config* config_create(char* version, char* send_directory, char* receive_directory,
-                      bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
-                      bool use_compression, bool use_metadata, int compression_level,
-                      bool use_sendfile, unsigned long long chunk_size);
-void config_delete(Config* config);
-bool config_send(int file_descriptor, const Config* config);
-Config* config_receive(int file_descriptor);
-bool is_remote_dest(const char* s);
-void config_parse_ssh_dest(Config* config);
+Config *config_create(char *version, char *send_directory,
+                      char *receive_directory, bool save_to_disk,
+                      bool use_multithreading, bool use_chunk_serialization,
+                       bool use_compression, bool use_metadata,
+                       int compression_level, bool use_sendfile,
+                       unsigned long long chunk_size);
+void config_delete(Config *config);
+bool config_send(int file_descriptor, Config *config);
+Config *config_receive(int file_descriptor);
+bool is_remote_dest(const char *s);
+void config_parse_ssh_dest(Config *config);

 #endif
@@ -2,8 +2,8 @@
 #include "log.h"
 #include "stdlib.h"

-Data* data_create_empty(size_t data_size) {
-  void* data = malloc(data_size);
+Data *data_create_empty(size_t data_size) {
+  void *data = malloc(data_size);
  if (data == NULL) {
    log_message(LOG_LEVEL_ERROR, "Could not allocate memory for empty data");
    return NULL;
@@ -11,8 +11,8 @@ Data* data_create_empty(size_t data_size) {
  return data_create(data, data_size);
 }

-Data* data_create_reserve(size_t size) {
-  Data* d = malloc(sizeof(Data));
+Data *data_create_reserve(size_t size) {
+  Data *d = malloc(sizeof(Data));
  if (d == NULL) {
    log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
    return NULL;
@@ -22,8 +22,8 @@ Data* data_create_reserve(size_t size) {
  return d;
 }

-Data* data_create(void* data, size_t data_size) {
-  Data* new_data = malloc(sizeof(Data));
+Data *data_create(void *data, size_t data_size) {
+  Data *new_data = malloc(sizeof(Data));
  if (new_data == NULL) {
    log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
    free(data);
@@ -34,9 +34,8 @@ Data* data_create(void* data, size_t data_size) {
  return new_data;
 }

-void data_destroy(Data* data) {
-  if (data == NULL)
-    return;
+void data_destroy(Data *data) {
+  if (data == NULL) return;
  free(data->data);
  free(data);
 }
@@ -4,13 +4,13 @@
 #include "stdlib.h"

 typedef struct {
-  void* data;
+  void *data;
  size_t size;
 } Data;

-Data* data_create_empty(size_t data_size);
-Data* data_create_reserve(size_t size);
-Data* data_create(void* data, size_t data_size);
-void data_destroy(Data* data);
+Data *data_create_empty(size_t data_size);
+Data *data_create_reserve(size_t size);
+Data *data_create(void *data, size_t data_size);
+void data_destroy(Data *data);

 #endif
@@ -7,8 +7,8 @@
 #define XXH_IMPLEMENTATION
 #include <xxhash.h>

-uint32_t delta_adler32(const void* data, uint32_t len) {
-  const uint8_t* p = (const uint8_t*)data;
+uint32_t delta_adler32(const void *data, uint32_t len) {
+  const uint8_t *p = (const uint8_t *)data;
  uint32_t s1 = 1;
  uint32_t s2 = 0;
  for (uint32_t i = 0; i < len; i++) {
@@ -18,20 +18,20 @@ uint32_t delta_adler32(const void* data, uint32_t len) {
  return (s2 << 16) | s1;
 }

-uint32_t delta_xxhash32(const void* data, uint32_t len) {
+uint32_t delta_xxhash32(const void *data, uint32_t len) {
  return XXH32(data, len, 0);
 }

-DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_file_size,
-                                       uint32_t block_size) {
+DeltaSignature *delta_signature_create(const void *old_file_data,
+                                        uint64_t old_file_size,
+                                        uint32_t block_size) {
  if (old_file_data == NULL || old_file_size == 0 || block_size == 0)
    return NULL;

  uint32_t block_count = (uint32_t)((old_file_size + block_size - 1) / block_size);

-  DeltaSignature* sig = malloc(sizeof(DeltaSignature));
-  if (!sig)
-    return NULL;
+  DeltaSignature *sig = malloc(sizeof(DeltaSignature));
+  if (!sig) return NULL;

  sig->file_size = old_file_size;
  sig->block_size = block_size;
@@ -42,11 +42,12 @@ DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_f
    return NULL;
  }

-  const uint8_t* data = (const uint8_t*)old_file_data;
+  const uint8_t *data = (const uint8_t *)old_file_data;
  for (uint32_t i = 0; i < block_count; i++) {
    uint64_t offset = (uint64_t)i * block_size;
-    uint32_t len =
-        (uint32_t)((old_file_size - offset < block_size) ? (old_file_size - offset) : block_size);
+    uint32_t len = (uint32_t)((old_file_size - offset < block_size)
+                                  ? (old_file_size - offset)
+                                  : block_size);
    sig->blocks[i].adler32 = delta_adler32(data + offset, len);
    sig->blocks[i].xxhash = delta_xxhash32(data + offset, len);
  }
@@ -54,16 +55,14 @@ DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_f
  return sig;
 }

-Data* delta_signature_serialize(const DeltaSignature* sig) {
-  if (!sig)
-    return NULL;
+Data *delta_signature_serialize(const DeltaSignature *sig) {
+  if (!sig) return NULL;

  uint64_t total = sizeof(uint64_t) + sizeof(uint32_t) + sizeof(uint32_t) +
                   (uint64_t)sig->block_count * (sizeof(uint32_t) + sizeof(uint32_t));

-  uint8_t* buf = malloc((size_t)total);
-  if (!buf)
-    return NULL;
+  uint8_t *buf = malloc((size_t)total);
+  if (!buf) return NULL;

  size_t pos = 0;
  memcpy(buf + pos, &sig->file_size, sizeof(uint64_t));
@@ -83,16 +82,15 @@ Data* delta_signature_serialize(const DeltaSignature* sig) {
  return data_create(buf, (size_t)total);
 }

-DeltaSignature* delta_signature_deserialize(const Data* data) {
+DeltaSignature *delta_signature_deserialize(const Data *data) {
  if (!data || data->size < sizeof(uint64_t) + sizeof(uint32_t) + sizeof(uint32_t))
    return NULL;

-  const uint8_t* buf = (const uint8_t*)data->data;
+  const uint8_t *buf = (const uint8_t *)data->data;
  size_t pos = 0;

-  DeltaSignature* sig = malloc(sizeof(DeltaSignature));
-  if (!sig)
-    return NULL;
+  DeltaSignature *sig = malloc(sizeof(DeltaSignature));
+  if (!sig) return NULL;

  memcpy(&sig->file_size, buf + pos, sizeof(uint64_t));
  pos += sizeof(uint64_t);
@@ -124,35 +122,31 @@ DeltaSignature* delta_signature_deserialize(const Data* data) {
  return sig;
 }

-void delta_signature_destroy(DeltaSignature* sig) {
-  if (!sig)
-    return;
+void delta_signature_destroy(DeltaSignature *sig) {
+  if (!sig) return;
  free(sig->blocks);
  free(sig);
 }

-static bool ensure_capacity(DeltaInstruction** instrs, uint32_t* capacity, uint32_t count) {
-  if (count < *capacity)
-    return true;
+static bool ensure_capacity(DeltaInstruction **instrs, uint32_t *capacity,
+                             uint32_t count) {
+  if (count < *capacity) return true;
  uint32_t new_cap = *capacity * 2;
-  DeltaInstruction* tmp = realloc(*instrs, new_cap * sizeof(DeltaInstruction));
-  if (!tmp)
-    return false;
+  DeltaInstruction *tmp = realloc(*instrs, new_cap * sizeof(DeltaInstruction));
+  if (!tmp) return false;
  *instrs = tmp;
  *capacity = new_cap;
  return true;
 }

-static bool flush_literal(DeltaInstruction** instrs, uint32_t* capacity, uint32_t* count,
-                          const uint8_t* data, uint64_t start, uint64_t end) {
-  if (start >= end)
-    return true;
+static bool flush_literal(DeltaInstruction **instrs, uint32_t *capacity,
+                           uint32_t *count, const uint8_t *data,
+                           uint64_t start, uint64_t end) {
+  if (start >= end) return true;
  uint32_t lit_len = (uint32_t)(end - start);
-  if (!ensure_capacity(instrs, capacity, *count))
-    return false;
-  uint8_t* lit_data = malloc(lit_len);
-  if (!lit_data)
-    return false;
+  if (!ensure_capacity(instrs, capacity, *count)) return false;
+  uint8_t *lit_data = malloc(lit_len);
+  if (!lit_data) return false;
  memcpy(lit_data, data + start, lit_len);
  (*instrs)[*count].type = DELTA_INSTR_LITERAL;
  (*instrs)[*count].literal.data = lit_data;
@@ -161,18 +155,17 @@ static bool flush_literal(DeltaInstruction** instrs, uint32_t* capacity, uint32_
  return true;
 }

-Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const DeltaSignature* sig,
-                     uint32_t block_size) {
+Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
+                      const DeltaSignature *sig, uint32_t block_size) {
  if (!new_file_data || !sig || new_file_size == 0 || block_size == 0)
    return NULL;

-  const uint8_t* new_data = (const uint8_t*)new_file_data;
+  const uint8_t *new_data = (const uint8_t *)new_file_data;

  uint32_t capacity = 64;
  uint32_t count = 0;
-  DeltaInstruction* instrs = malloc(capacity * sizeof(DeltaInstruction));
-  if (!instrs)
-    return NULL;
+  DeltaInstruction *instrs = malloc(capacity * sizeof(DeltaInstruction));
+  if (!instrs) return NULL;

  uint64_t literal_start = 0;
  bool has_literal = false;
@@ -183,17 +176,20 @@ Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const De
  bool rolling_valid = false;

  while (i < new_file_size) {
-    uint32_t window_len =
-        (uint32_t)((new_file_size - i < block_size) ? (new_file_size - i) : block_size);
+    uint32_t window_len = (uint32_t)((new_file_size - i < block_size)
+                                         ? (new_file_size - i)
+                                         : block_size);
    bool full_window = (window_len == block_size);

    uint32_t adler;
    if (rolling_valid && full_window) {
      uint8_t old_byte = new_data[i - 1];
      uint8_t new_byte = new_data[i + block_size - 1];
-      s1 = (s1 + DELTA_ADLER32_MODULUS - old_byte + new_byte) % DELTA_ADLER32_MODULUS;
+      s1 = (s1 + DELTA_ADLER32_MODULUS - old_byte + new_byte) %
+           DELTA_ADLER32_MODULUS;
      s2 = (s2 + DELTA_ADLER32_MODULUS -
-            (uint32_t)((uint64_t)block_size * old_byte % DELTA_ADLER32_MODULUS) + s1 - 1) %
+            (uint32_t)((uint64_t)block_size * old_byte % DELTA_ADLER32_MODULUS) +
+            s1 - 1) %
           DELTA_ADLER32_MODULUS;
      adler = (s2 << 16) | s1;
    } else {
@@ -213,7 +209,8 @@ Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const De
        uint32_t xxh = delta_xxhash32(new_data + i, window_len);
        if (xxh == sig->blocks[j].xxhash) {
          if (has_literal) {
-            if (!flush_literal(&instrs, &capacity, &count, new_data, literal_start, i)) {
+            if (!flush_literal(&instrs, &capacity, &count, new_data,
+                               literal_start, i)) {
              free(instrs);
              return NULL;
            }
@@ -248,13 +245,14 @@ Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const De
  }

  if (has_literal) {
-    if (!flush_literal(&instrs, &capacity, &count, new_data, literal_start, new_file_size)) {
+    if (!flush_literal(&instrs, &capacity, &count, new_data,
+                       literal_start, new_file_size)) {
      free(instrs);
      return NULL;
    }
  }

-  Delta* delta = malloc(sizeof(Delta));
+  Delta *delta = malloc(sizeof(Delta));
  if (!delta) {
    for (uint32_t k = 0; k < count; k++) {
      if (instrs[k].type == DELTA_INSTR_LITERAL)
@@ -281,14 +279,12 @@ Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const De
  return delta;
 }

-Data* delta_serialize(const Delta* delta) {
-  if (!delta)
-    return NULL;
+Data *delta_serialize(const Delta *delta) {
+  if (!delta) return NULL;

  uint64_t total = sizeof(uint64_t) + sizeof(uint32_t) + delta->delta_size;
-  uint8_t* buf = malloc((size_t)total);
-  if (!buf)
-    return NULL;
+  uint8_t *buf = malloc((size_t)total);
+  if (!buf) return NULL;

  size_t pos = 0;
  memcpy(buf + pos, &delta->new_file_size, sizeof(uint64_t));
@@ -311,7 +307,8 @@ Data* delta_serialize(const Delta* delta) {
    } else {
      memcpy(buf + pos, &delta->instructions[i].literal.length, sizeof(uint32_t));
      pos += sizeof(uint32_t);
-      memcpy(buf + pos, delta->instructions[i].literal.data, delta->instructions[i].literal.length);
+      memcpy(buf + pos, delta->instructions[i].literal.data,
+             delta->instructions[i].literal.length);
      pos += delta->instructions[i].literal.length;
    }
  }
@@ -319,16 +316,15 @@ Data* delta_serialize(const Delta* delta) {
  return data_create(buf, (size_t)total);
 }

-Delta* delta_deserialize(const Data* data) {
+Delta *delta_deserialize(const Data *data) {
  if (!data || data->size < sizeof(uint64_t) + sizeof(uint32_t))
    return NULL;

-  const uint8_t* buf = (const uint8_t*)data->data;
+  const uint8_t *buf = (const uint8_t *)data->data;
  size_t pos = 0;

-  Delta* delta = malloc(sizeof(Delta));
-  if (!delta)
-    return NULL;
+  Delta *delta = malloc(sizeof(Delta));
+  if (!delta) return NULL;

  memcpy(&delta->new_file_size, buf + pos, sizeof(uint64_t));
  pos += sizeof(uint64_t);
@@ -376,10 +372,6 @@ Delta* delta_deserialize(const Data* data) {
      delta->delta_size += sizeof(uint32_t) * 3;
    } else if (type == DELTA_OP_LITERAL) {
      if (pos + sizeof(uint32_t) > data->size) {
-        for (uint32_t k = 0; k < i; k++) {
-          if (delta->instructions[k].type == DELTA_INSTR_LITERAL)
-            free(delta->instructions[k].literal.data);
-        }
        free(delta->instructions);
        free(delta);
        return NULL;
@@ -390,10 +382,6 @@ Delta* delta_deserialize(const Data* data) {

      uint32_t lit_len = delta->instructions[i].literal.length;
      if (pos + lit_len > data->size) {
-        for (uint32_t k = 0; k < i; k++) {
-          if (delta->instructions[k].type == DELTA_INSTR_LITERAL)
-            free(delta->instructions[k].literal.data);
-        }
        free(delta->instructions);
        free(delta);
        return NULL;
@@ -421,22 +409,21 @@ Delta* delta_deserialize(const Data* data) {
  return delta;
 }

-void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta,
+void *delta_apply(const void *old_data, uint64_t old_size, const Delta *delta,
                  uint32_t block_size) {
-  if (!old_data || !delta)
-    return NULL;
+  if (!old_data || !delta) return NULL;

-  void* output = malloc((size_t)delta->new_file_size);
-  if (!output)
-    return NULL;
+  void *output = malloc((size_t)delta->new_file_size);
+  if (!output) return NULL;

-  uint8_t* out = (uint8_t*)output;
-  const uint8_t* old = (const uint8_t*)old_data;
+  uint8_t *out = (uint8_t *)output;
+  uint8_t *old = (uint8_t *)old_data;
  uint64_t out_pos = 0;

  for (uint32_t i = 0; i < delta->instruction_count; i++) {
    if (delta->instructions[i].type == DELTA_INSTR_BLOCK_MATCH) {
-      uint64_t src_offset = (uint64_t)delta->instructions[i].match.block_index * block_size;
+      uint64_t src_offset = (uint64_t)delta->instructions[i].match.block_index *
+                             block_size;
      src_offset += delta->instructions[i].match.block_offset;
      uint32_t len = delta->instructions[i].match.length;

@@ -461,9 +448,8 @@ void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta,
  return output;
 }

-void delta_destroy(Delta* delta) {
-  if (!delta)
-    return;
+void delta_destroy(Delta *delta) {
+  if (!delta) return;
  for (uint32_t i = 0; i < delta->instruction_count; i++) {
    if (delta->instructions[i].type == DELTA_INSTR_LITERAL)
      free(delta->instructions[i].literal.data);
@@ -484,9 +470,8 @@ bool delta_should_attempt(uint64_t old_size, uint64_t new_size, uint64_t max_fil
  return true;
 }

-bool delta_is_worthwhile(const Delta* delta, uint64_t new_file_size) {
-  if (!delta || delta->instruction_count == 0)
-    return false;
+bool delta_is_worthwhile(const Delta *delta, uint64_t new_file_size) {
+  if (!delta || delta->instruction_count == 0) return false;

  bool has_match = false;
  for (uint32_t i = 0; i < delta->instruction_count; i++) {
@@ -495,8 +480,7 @@ bool delta_is_worthwhile(const Delta* delta, uint64_t new_file_size) {
      break;
    }
  }
-  if (!has_match)
-    return false;
+  if (!has_match) return false;

  double ratio = (double)delta->delta_size / (double)new_file_size;
  return ratio < DELTA_FALLBACK_RATIO;
@@ -6,17 +6,17 @@
 #include <stdint.h>
 #include <stddef.h>

-#define DELTA_BLOCK_SIZE_DEFAULT 8192U
-#define DELTA_BLOCK_SIZE_MIN 1024U
-#define DELTA_BLOCK_SIZE_MAX 65536U
-#define DELTA_MIN_FILE_SIZE 16384ULL
-#define DELTA_MAX_FILE_SIZE (256ULL * 1024 * 1024)
-#define DELTA_MAX_SIZE_RATIO 10.0
-#define DELTA_FALLBACK_RATIO 0.7
-#define DELTA_ADLER32_MODULUS 65521U
+#define DELTA_BLOCK_SIZE_DEFAULT  8192U
+#define DELTA_BLOCK_SIZE_MIN      1024U
+#define DELTA_BLOCK_SIZE_MAX      65536U
+#define DELTA_MIN_FILE_SIZE       16384ULL
+#define DELTA_MAX_FILE_SIZE       (256ULL * 1024 * 1024)
+#define DELTA_MAX_SIZE_RATIO      10.0
+#define DELTA_FALLBACK_RATIO      0.7
+#define DELTA_ADLER32_MODULUS     65521U

-#define DELTA_OP_BLOCK_MATCH 0x01
-#define DELTA_OP_LITERAL 0x02
+#define DELTA_OP_BLOCK_MATCH  0x01
+#define DELTA_OP_LITERAL      0x02

 typedef struct {
  uint32_t adler32;
@@ -27,10 +27,13 @@ typedef struct {
  uint64_t file_size;
  uint32_t block_size;
  uint32_t block_count;
-  DeltaBlockSig* blocks;
+  DeltaBlockSig *blocks;
 } DeltaSignature;

-typedef enum { DELTA_INSTR_BLOCK_MATCH = 0x01, DELTA_INSTR_LITERAL = 0x02 } DeltaInstrType;
+typedef enum {
+  DELTA_INSTR_BLOCK_MATCH = 0x01,
+  DELTA_INSTR_LITERAL     = 0x02
+} DeltaInstrType;

 typedef struct {
  DeltaInstrType type;
@@ -41,7 +44,7 @@ typedef struct {
      uint32_t length;
    } match;
    struct {
-      uint8_t* data;
+      uint8_t *data;
      uint32_t length;
    } literal;
  };
@@ -50,27 +53,29 @@ typedef struct {
 typedef struct {
  uint64_t new_file_size;
  uint32_t instruction_count;
-  DeltaInstruction* instructions;
+  DeltaInstruction *instructions;
  uint64_t delta_size;
 } Delta;

-DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_file_size,
-                                       uint32_t block_size);
-Data* delta_signature_serialize(const DeltaSignature* sig);
-DeltaSignature* delta_signature_deserialize(const Data* data);
-void delta_signature_destroy(DeltaSignature* sig);
+DeltaSignature *delta_signature_create(const void *old_file_data,
+                                        uint64_t old_file_size,
+                                        uint32_t block_size);
+Data *delta_signature_serialize(const DeltaSignature *sig);
+DeltaSignature *delta_signature_deserialize(const Data *data);
+void delta_signature_destroy(DeltaSignature *sig);

-Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const DeltaSignature* sig,
-                     uint32_t block_size);
-Data* delta_serialize(const Delta* delta);
-Delta* delta_deserialize(const Data* data);
-void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta, uint32_t block_size);
-void delta_destroy(Delta* delta);
+Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
+                      const DeltaSignature *sig, uint32_t block_size);
+Data *delta_serialize(const Delta *delta);
+Delta *delta_deserialize(const Data *data);
+void *delta_apply(const void *old_data, uint64_t old_size, const Delta *delta,
+                  uint32_t block_size);
+void delta_destroy(Delta *delta);

 bool delta_should_attempt(uint64_t old_size, uint64_t new_size, uint64_t max_file_size);
-bool delta_is_worthwhile(const Delta* delta, uint64_t new_file_size);
+bool delta_is_worthwhile(const Delta *delta, uint64_t new_file_size);

-uint32_t delta_adler32(const void* data, uint32_t len);
-uint32_t delta_xxhash32(const void* data, uint32_t len);
+uint32_t delta_adler32(const void *data, uint32_t len);
+uint32_t delta_xxhash32(const void *data, uint32_t len);

 #endif
@@ -20,15 +20,15 @@
 #include "protocol.h"
 #include "utils.h"

-File* file_create(const char* path) {
-  File* file = (File*)malloc(sizeof(File));
+File *file_create(const char *path) {
+  File *file = (File *)malloc(sizeof(File));
  if (file == NULL) {
    perror("ERROR: Could not allocate memory for file struct");
    return NULL;
  }

  int path_len = strlen(path);
-  file->path = (char*)malloc(path_len + 1);
+  file->path = (char *)malloc(path_len + 1);
  if (file->path == NULL) {
    free(file);
    return NULL;
@@ -45,10 +45,10 @@ File* file_create(const char* path) {
  return file;
 }

-void file_destroy(void* item) {
+void file_destroy(void *item) {
  if (item == NULL)
    return;
-  File* file = (File*)item;
+  File *file = (File *)item;
  data_destroy(file->data);
  file->data = NULL;
  file_metadata_destroy(file->metadata);
@@ -58,8 +58,8 @@ void file_destroy(void* item) {
  free(file);
 }

-FileMetadata* file_metadata_create(const struct stat* stats) {
-  FileMetadata* m = malloc(sizeof(FileMetadata));
+FileMetadata *file_metadata_create(struct stat *stats) {
+  FileMetadata *m = malloc(sizeof(FileMetadata));
  if (m == NULL) {
    perror("ERROR: Could not allocate memory for file metadata");
    return NULL;
@@ -76,13 +76,12 @@ FileMetadata* file_metadata_create(const struct stat* stats) {
  return m;
 }

-void file_metadata_destroy(void* metadata) {
+void file_metadata_destroy(void *metadata) {
  free(metadata);
 }

-bool file_load_data(File* file) {
-  if (file == NULL)
-    return false;
+bool file_load_data(File *file) {
+  if (file == NULL) return false;
  if (file->data->data == NULL) {
    file->data->data = malloc(file->data->size);
    if (file->data->data == NULL) {
@@ -98,10 +97,9 @@ bool file_load_data(File* file) {
  return true;
 }

-bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
-                            int compression_level, bool send_path) {
-  const Data* data_to_send = file->data;
-  Data* compressed_data = NULL;
+bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path) {
+  Data *data_to_send = file->data;
+  Data *compressed_data = NULL;
  if (compression_level > 0) {
    compressed_data = data_compress(file->data, compression_level);
    if (compressed_data == NULL) {
@@ -126,61 +124,42 @@ bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
  return true;
 }

-bool file_save_to_disk(const char* root_directory, File* file) {
-  char* disk_path = path_cat((char*)root_directory, file->path);
-  if (disk_path == NULL)
-    return false;
+bool file_save_to_disk(const char *root_directory, File *file) {
+  char *disk_path = path_cat((char *)root_directory, file->path);
+  if (disk_path == NULL) return false;
  bool ok = to_disk(disk_path, file->data->data, file->data->size);
-  if (ok)
-    file_restore_metadata(disk_path, file->metadata);
+  if (ok) file_restore_metadata(disk_path, file->metadata);
  free(disk_path);
  return ok;
 }

-static void* old_data_from_path(const char* full_path, unsigned long long old_size) {
-  void* data = malloc((size_t)old_size);
-  if (!data)
-    return NULL;
-  FILE* fp = fopen(full_path, "rb");
-  if (!fp) {
-    free(data);
-    return NULL;
-  }
+static void *old_data_from_path(const char *full_path, unsigned long long old_size) {
+  void *data = malloc((size_t)old_size);
+  if (!data) return NULL;
+  FILE *fp = fopen(full_path, "rb");
+  if (!fp) { free(data); return NULL; }
  size_t nread = fread(data, 1, (size_t)old_size, fp);
  fclose(fp);
-  if (nread != (size_t)old_size) {
-    free(data);
-    return NULL;
-  }
+  if (nread != (size_t)old_size) { free(data); return NULL; }
  return data;
 }

-static File* receive_delta_file(int fd, const Config* config, const char* check_path,
-                                void* old_data, unsigned long long old_size) {
-  if (!old_data)
-    return NULL;
+static File *receive_delta_file(int fd, Config *config, const char *check_path,
+                                 void *old_data, unsigned long long old_size) {
+  if (!old_data) return NULL;

-  DeltaSignature* sig = delta_signature_create(old_data, old_size, config->delta_block_size);
-  if (!sig) {
-    free(old_data);
-    return NULL;
-  }
+  DeltaSignature *sig = delta_signature_create(old_data, old_size,
+                                                config->delta_block_size);
+  if (!sig) { free(old_data); return NULL; }

-  Data* sig_data = delta_signature_serialize(sig);
-  if (!sig_data) {
-    delta_signature_destroy(sig);
-    free(old_data);
-    return NULL;
-  }
+  Data *sig_data = delta_signature_serialize(sig);
+  if (!sig_data) { delta_signature_destroy(sig); free(old_data); return NULL; }

-  bool sig_sent = send_status(fd, STATUS_DELTA_SIGNATURE) && send_data(fd, sig_data);
+  bool sig_sent = send_status(fd, STATUS_DELTA_SIGNATURE) &&
+                  send_data(fd, sig_data);
  data_destroy(sig_data);

-  if (!sig_sent) {
-    delta_signature_destroy(sig);
-    free(old_data);
-    return NULL;
-  }
+  if (!sig_sent) { delta_signature_destroy(sig); free(old_data); return NULL; }

  Status resp;
  if (!receive_status(fd, &resp)) {
@@ -190,7 +169,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
  }

  if (resp == STATUS_DELTA_DATA) {
-    Data* delta_data = receive_data(fd);
+    Data *delta_data = receive_data(fd);
    if (!delta_data) {
      delta_signature_destroy(sig);
      free(old_data);
@@ -198,7 +177,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
      return NULL;
    }

-    Data* raw_delta = delta_data;
+    Data *raw_delta = delta_data;
    if (config->use_compression) {
      raw_delta = data_decompress(delta_data);
      data_destroy(delta_data);
@@ -210,7 +189,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
      }
    }

-    Delta* delta = delta_deserialize(raw_delta);
+    Delta *delta = delta_deserialize(raw_delta);
    data_destroy(raw_delta);
    if (!delta) {
      free(old_data);
@@ -219,7 +198,8 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
      return NULL;
    }

-    void* new_data = delta_apply(old_data, old_size, delta, config->delta_block_size);
+    void *new_data = delta_apply(old_data, old_size, delta,
+                                  config->delta_block_size);
    uint64_t new_size = delta->new_file_size;
    delta_destroy(delta);

@@ -230,7 +210,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
      return NULL;
    }

-    File* file = file_create(check_path);
+    File *file = file_create(check_path);
    if (!file) {
      free(new_data);
      free(old_data);
@@ -264,23 +244,16 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
    delta_signature_destroy(sig);
    free(old_data);

-    File* file = file_create(check_path);
-    if (!file) {
-      send_status(fd, STATUS_ERROR);
-      return NULL;
-    }
+    File *file = file_create(check_path);
+    if (!file) { send_status(fd, STATUS_ERROR); return NULL; }

    if (config->use_metadata) {
      int meta_ok = 1;
      file->metadata = metadata_receive(fd, &meta_ok);
-      if (!meta_ok) {
-        file_destroy(file);
-        send_status(fd, STATUS_ERROR);
-        return NULL;
-      }
+      if (!meta_ok) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
    }

-    Data* file_data = receive_data(fd);
+    Data *file_data = receive_data(fd);
    if (file_data == NULL) {
      file_destroy(file);
      send_status(fd, STATUS_ERROR);
@@ -288,13 +261,9 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
    }

    if (config->use_compression) {
-      Data* uncompressed = data_decompress(file_data);
+      Data *uncompressed = data_decompress(file_data);
      data_destroy(file_data);
-      if (uncompressed == NULL) {
-        file_destroy(file);
-        send_status(fd, STATUS_ERROR);
-        return NULL;
-      }
+      if (uncompressed == NULL) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
      file_data = uncompressed;
    }

@@ -308,13 +277,10 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
  return NULL;
 }

-File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
+File *receive_incremental_check(int fd, Config *config, bool *skipped) {
  *skipped = false;
-  char* check_path = receive_str(fd);
-  if (check_path == NULL) {
-    send_status(fd, STATUS_ERROR);
-    return NULL;
-  }
+  char *check_path = receive_str(fd);
+  if (check_path == NULL) { send_status(fd, STATUS_ERROR); return NULL; }

  unsigned long long check_size;
  long long check_mtime;
@@ -325,20 +291,17 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
    return NULL;
  }

-  char* full_path = path_cat(config->receive_root_directory, check_path);
+  char *full_path = path_cat(config->receive_root_directory, check_path);
  struct stat st;
  bool has_old_file = (full_path && stat(full_path, &st) == 0);
  unsigned long long old_size = has_old_file ? (unsigned long long)st.st_size : 0;

-  bool match = has_old_file && (unsigned long long)st.st_size == check_size &&
+  bool match = has_old_file &&
+               (unsigned long long)st.st_size == check_size &&
               (long long)st.st_mtime == check_mtime;

  if (match) {
-    if (!send_status(fd, STATUS_OK)) {
-      free(full_path);
-      free(check_path);
-      return NULL;
-    }
+    if (!send_status(fd, STATUS_OK)) { free(full_path); free(check_path); return NULL; }
    free(full_path);
    free(check_path);
    *skipped = true;
@@ -349,8 +312,9 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
                   delta_should_attempt(old_size, check_size, config->delta_max_file_size);

  if (try_delta) {
-    void* old_data = old_data_from_path(full_path, old_size);
-    File* delta_file = receive_delta_file(fd, config, check_path, old_data, old_size);
+    void *old_data = old_data_from_path(full_path, old_size);
+    File *delta_file = receive_delta_file(fd, config, check_path,
+                                           old_data, old_size);
    if (delta_file) {
      free(full_path);
      free(check_path);
@@ -367,25 +331,18 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
    }
  }

-  File* file = file_create(check_path);
+  File *file = file_create(check_path);
  free(check_path);
  free(full_path);
-  if (file == NULL) {
-    send_status(fd, STATUS_ERROR);
-    return NULL;
-  }
+  if (file == NULL) { send_status(fd, STATUS_ERROR); return NULL; }

  if (config->use_metadata) {
    int meta_ok = 1;
    file->metadata = metadata_receive(fd, &meta_ok);
-    if (!meta_ok) {
-      file_destroy(file);
-      send_status(fd, STATUS_ERROR);
-      return NULL;
-    }
+    if (!meta_ok) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
  }

-  Data* file_data = receive_data(fd);
+  Data *file_data = receive_data(fd);
  if (file_data == NULL) {
    file_destroy(file);
    send_status(fd, STATUS_ERROR);
@@ -393,13 +350,9 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
  }

  if (config->use_compression) {
-    Data* uncompressed = data_decompress(file_data);
+    Data *uncompressed = data_decompress(file_data);
    data_destroy(file_data);
-    if (uncompressed == NULL) {
-      file_destroy(file);
-      send_status(fd, STATUS_ERROR);
-      return NULL;
-    }
+    if (uncompressed == NULL) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
    file_data = uncompressed;
  }

@@ -408,15 +361,15 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
  return file;
 }

-bool to_disk(const char* path, const void* data, unsigned long long data_size) {
-  char* directory = str_dup(path);
-  char* dir_to_free = directory;
+bool to_disk(const char *path, const void *data, unsigned long long data_size) {
+  char *directory = str_dup(path);
+  char *dir_to_free = directory;
  directory = dirname(directory);
  if (!mkdir_r(directory)) {
    free(dir_to_free);
    return false;
  }
-  FILE* file_pointer = fopen(path, "wb");
+  FILE *file_pointer = fopen(path, "wb");
  if (file_pointer == NULL) {
    perror("Could not open File");
    free(dir_to_free);
@@ -433,13 +386,10 @@ bool to_disk(const char* path, const void* data, unsigned long long data_size) {
  return true;
 }

-bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int compression_level,
-                        bool send_path) {
+bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path) {
  (void)compression_level;
-  if (send_path && !send_str(file_descriptor, file->path))
-    return false;
-  if (use_metadata && !metadata_send(file_descriptor, file->metadata))
-    return false;
+  if (send_path && !send_str(file_descriptor, file->path)) return false;
+  if (use_metadata && !metadata_send(file_descriptor, file->metadata)) return false;

  int fd = open(file->path, O_RDONLY);
  if (fd == -1) {
@@ -454,7 +404,7 @@ bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int
  }

  off_t offset = 0;
-  while ((unsigned long long)offset < file_size) {
+  while (offset < file_size) {
    ssize_t sent = sendfile(file_descriptor, fd, &offset, file_size - offset);
    if (sent == -1) {
      perror("sendfile failed");
@@ -467,29 +417,24 @@ bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int
  return true;
 }

-File* file_receive(const Config* config, int file_descriptor) {
-  char* path = receive_str(file_descriptor);
-  if (path == NULL)
-    return NULL;
-  File* file = file_create(path);
+File *file_receive(Config *config, int file_descriptor) {
+  char *path = receive_str(file_descriptor);
+  if (path == NULL) return NULL;
+  File *file = file_create(path);
  free(path);
-  if (file == NULL)
-    return NULL;
+  if (file == NULL) return NULL;
  if (config->use_metadata) {
    int meta_ok = 1;
    file->metadata = metadata_receive(file_descriptor, &meta_ok);
-    if (!meta_ok) {
-      file_destroy(file);
-      return NULL;
-    }
+    if (!meta_ok) { file_destroy(file); return NULL; }
  }
-  Data* file_data = receive_data(file_descriptor);
+  Data *file_data = receive_data(file_descriptor);
  if (file_data == NULL) {
    file_destroy(file);
    return NULL;
  }
  if (config->use_compression) {
-    Data* file_data_uncompressed = data_decompress(file_data);
+    Data *file_data_uncompressed = data_decompress(file_data);
    data_destroy(file_data);
    if (file_data_uncompressed == NULL) {
      file_destroy(file);
@@ -502,13 +447,14 @@ File* file_receive(const Config* config, int file_descriptor) {
  return file;
 }

-size_t file_content_to_buffer(File* file) {
-  FILE* file_pointer = fopen(file->path, "rb");
+size_t file_content_to_buffer(File *file) {
+  FILE *file_pointer = fopen(file->path, "rb");
  if (file_pointer == NULL) {
    perror("Could not open the file!");
    return 0;
  }
-  size_t bytes_read = fread(file->data->data, 1, file->data->size, file_pointer);
+  size_t bytes_read =
+      fread(file->data->data, 1, file->data->size, file_pointer);
  if (bytes_read != (size_t)file->data->size) {
    fclose(file_pointer);
    perror("Read unexpected number of bytes from File!");
@@ -518,22 +464,21 @@ size_t file_content_to_buffer(File* file) {
  return bytes_read;
 }

-int receive_manifest(int fd, const Config* config, int* next_status) {
+int receive_manifest(int fd, Config *config, int *next_status) {
  int count;
-  if (!receive_int(fd, &count))
-    return -1;
-  ArrayList* manifest = array_list_create(free);
+  if (!receive_int(fd, &count)) return -1;
+  ArrayList *manifest = array_list_create(free);
  if (manifest) {
    for (int i = 0; i < count; i++) {
-      char* s = receive_str(fd);
-      if (s)
-        array_list_add(manifest, s);
+      char *s = receive_str(fd);
+      if (s) array_list_add(manifest, s);
    }
    fprintf(stderr, "Deleting files not in manifest...\n");
    delete_extras(config->receive_root_directory, manifest);
    array_list_delete(manifest);
  }
-  if (!receive_status(fd, next_status))
-    return -1;
+  if (!receive_status(fd, next_status)) return -1;
  return 0;
 }
+
+
@@ -15,25 +15,23 @@ typedef struct {
 } FileMetadata;

 typedef struct {
-  char* path;
-  Data* data;
-  FileMetadata* metadata;
+  char *path;
+  Data *data;
+  FileMetadata *metadata;
 } File;

-File* file_create(const char* path);
-void file_destroy(void* item);
-bool file_load_data(File* file);
-File* file_receive(const Config* config, int file_descriptor);
-bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
-                            int compression_level, bool send_path);
-bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int compression_level,
-                        bool send_path);
-size_t file_content_to_buffer(File* file);
-FileMetadata* file_metadata_create(const struct stat* stats);
-void file_metadata_destroy(void* metadata);
-bool to_disk(const char* path, const void* data, unsigned long long data_size);
-bool file_save_to_disk(const char* root_directory, File* file);
-File* receive_incremental_check(int fd, const Config* config, bool* skipped);
-int receive_manifest(int fd, const Config* config, int* next_status);
+File *file_create(const char *path);
+void file_destroy(void *item);
+bool file_load_data(File *file);
+File *file_receive(Config *config, int file_descriptor);
+bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path);
+bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path);
+size_t file_content_to_buffer(File *file);
+FileMetadata *file_metadata_create(struct stat *stats);
+void file_metadata_destroy(void *metadata);
+bool to_disk(const char *path, const void *data, unsigned long long data_size);
+bool file_save_to_disk(const char *root_directory, File *file);
+File *receive_incremental_check(int fd, Config *config, bool *skipped);
+int receive_manifest(int fd, Config *config, int *next_status);

 #endif
@@ -3,21 +3,22 @@
 #include <stdio.h>
 #include <time.h>

-static const char* log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
+static const char *log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
 static LogLevel current_log_level = LOG_LEVEL_WARNING;

 void set_log_level(LogLevel level) {
  current_log_level = level;
 }

-void log_message(LogLevel log_level, char* format, ...) {
+void log_message(LogLevel log_level, char *format, ...) {
  if (log_level < current_log_level)
    return;
  time_t now = time(NULL);
-  const struct tm* t = localtime(&now);
+  struct tm *t = localtime(&now);

-  fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900, t->tm_mon + 1,
-          t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, log_level_strings[log_level]);
+  fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900,
+          t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec,
+          log_level_strings[log_level]);

  va_list args;
  va_start(args, format);
@@ -1,9 +1,14 @@
 #ifndef LOG_H
 #define LOG_H

-typedef enum { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR } LogLevel;
+typedef enum {
+  LOG_LEVEL_DEBUG,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_WARNING,
+  LOG_LEVEL_ERROR
+} LogLevel;

-void log_message(LogLevel log_level, char* message, ...);
+void log_message(LogLevel log_level, char *message, ...);
 void set_log_level(LogLevel level);

 #endif
@@ -8,45 +8,35 @@
 #include <time.h>
 #include <unistd.h>

-void metadata_to_buf(char** buf, const FileMetadata* m) {
+void metadata_to_buf(char **buf, FileMetadata *m) {
  int present = (m != NULL) ? 1 : 0;
  memcpy(*buf, &present, sizeof(int));
  *buf += sizeof(int);
  if (m == NULL)
    return;
-  memcpy(*buf, &m->mode, sizeof(mode_t));
-  *buf += sizeof(mode_t);
-  memcpy(*buf, &m->uid, sizeof(uid_t));
-  *buf += sizeof(uid_t);
-  memcpy(*buf, &m->gid, sizeof(gid_t));
-  *buf += sizeof(gid_t);
-  memcpy(*buf, &m->mtime_sec, sizeof(time_t));
-  *buf += sizeof(time_t);
-  memcpy(*buf, &m->mtime_nsec, sizeof(long));
-  *buf += sizeof(long);
+  memcpy(*buf, &m->mode, sizeof(mode_t));        *buf += sizeof(mode_t);
+  memcpy(*buf, &m->uid, sizeof(uid_t));          *buf += sizeof(uid_t);
+  memcpy(*buf, &m->gid, sizeof(gid_t));          *buf += sizeof(gid_t);
+  memcpy(*buf, &m->mtime_sec, sizeof(time_t));   *buf += sizeof(time_t);
+  memcpy(*buf, &m->mtime_nsec, sizeof(long));    *buf += sizeof(long);
 }

-FileMetadata* metadata_from_buf(char** buf) {
+FileMetadata *metadata_from_buf(char **buf) {
  int present;
  memcpy(&present, *buf, sizeof(int));
  *buf += sizeof(int);
  if (!present)
    return NULL;
-  FileMetadata* m = malloc(sizeof(FileMetadata));
-  memcpy(&m->mode, *buf, sizeof(mode_t));
-  *buf += sizeof(mode_t);
-  memcpy(&m->uid, *buf, sizeof(uid_t));
-  *buf += sizeof(uid_t);
-  memcpy(&m->gid, *buf, sizeof(gid_t));
-  *buf += sizeof(gid_t);
-  memcpy(&m->mtime_sec, *buf, sizeof(time_t));
-  *buf += sizeof(time_t);
-  memcpy(&m->mtime_nsec, *buf, sizeof(long));
-  *buf += sizeof(long);
+  FileMetadata *m = malloc(sizeof(FileMetadata));
+  memcpy(&m->mode, *buf, sizeof(mode_t));        *buf += sizeof(mode_t);
+  memcpy(&m->uid, *buf, sizeof(uid_t));          *buf += sizeof(uid_t);
+  memcpy(&m->gid, *buf, sizeof(gid_t));          *buf += sizeof(gid_t);
+  memcpy(&m->mtime_sec, *buf, sizeof(time_t));   *buf += sizeof(time_t);
+  memcpy(&m->mtime_nsec, *buf, sizeof(long));    *buf += sizeof(long);
  return m;
 }

-bool metadata_send(int file_descriptor, FileMetadata* m) {
+bool metadata_send(int file_descriptor, FileMetadata *m) {
  if (m == NULL) {
    int zero = 0;
    return send_n_data(file_descriptor, &zero, sizeof(int));
@@ -60,40 +50,32 @@ bool metadata_send(int file_descriptor, FileMetadata* m) {
         send_n_data(file_descriptor, &m->mtime_nsec, sizeof(long));
 }

-FileMetadata* metadata_receive(int file_descriptor, int* ok) {
+FileMetadata *metadata_receive(int file_descriptor, int *ok) {
  int present;
  if (!receive_n_data(file_descriptor, &present, sizeof(int))) {
-    if (ok)
-      *ok = 0;
+    if (ok) *ok = 0;
    return NULL;
  }
  if (!present) {
-    if (ok)
-      *ok = 1;
-    return NULL;
-  }
-  FileMetadata* m = malloc(sizeof(FileMetadata));
-  if (m == NULL) {
-    if (ok)
-      *ok = 0;
+    if (ok) *ok = 1;
    return NULL;
  }
+  FileMetadata *m = malloc(sizeof(FileMetadata));
+  if (m == NULL) { if (ok) *ok = 0; return NULL; }
  if (!receive_n_data(file_descriptor, &m->mode, sizeof(mode_t)) ||
      !receive_n_data(file_descriptor, &m->uid, sizeof(uid_t)) ||
      !receive_n_data(file_descriptor, &m->gid, sizeof(gid_t)) ||
      !receive_n_data(file_descriptor, &m->mtime_sec, sizeof(time_t)) ||
      !receive_n_data(file_descriptor, &m->mtime_nsec, sizeof(long))) {
    free(m);
-    if (ok)
-      *ok = 0;
+    if (ok) *ok = 0;
    return NULL;
  }
-  if (ok)
-    *ok = 1;
+  if (ok) *ok = 1;
  return m;
 }

-void file_restore_metadata(const char* path, FileMetadata* metadata) {
+void file_restore_metadata(const char *path, FileMetadata *metadata) {
  if (metadata == NULL)
    return;
  chmod(path, metadata->mode & 07777);
@@ -5,13 +5,12 @@
 #include <stdbool.h>
 #include <sys/stat.h>

-#define FILE_METADATA_WIRE_SIZE                                                                    \
-  (sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))
+#define FILE_METADATA_WIRE_SIZE (sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))

-void metadata_to_buf(char** buf, const FileMetadata* m);
-FileMetadata* metadata_from_buf(char** buf);
-bool metadata_send(int file_descriptor, FileMetadata* m);
-FileMetadata* metadata_receive(int file_descriptor, int* ok);
-void file_restore_metadata(const char* path, FileMetadata* metadata);
+void metadata_to_buf(char **buf, FileMetadata *m);
+FileMetadata *metadata_from_buf(char **buf);
+bool metadata_send(int file_descriptor, FileMetadata *m);
+FileMetadata *metadata_receive(int file_descriptor, int *ok);
+void file_restore_metadata(const char *path, FileMetadata *metadata);

 #endif
@@ -13,11 +13,11 @@
 #include <string.h>
 #include <threads.h>

-PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
-                                                      Queue* queue_loader) {
-  PipelineContextSender* context = malloc(sizeof(PipelineContextSender));
-  if (context == NULL)
-    return NULL;
+PipelineContextSender *pipeline_context_sender_create(Config *config,
+                                                      Queue *queue_scanner,
+                                                      Queue *queue_loader) {
+  PipelineContextSender *context = malloc(sizeof(PipelineContextSender));
+  if (context == NULL) return NULL;
  context->config = config;
  context->queue_scanner = queue_scanner;
  context->queue_loader = queue_loader;
@@ -37,7 +37,7 @@ PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* que
  return context;
 }

-void pipeline_context_sender_destroy(PipelineContextSender* context) {
+void pipeline_context_sender_destroy(PipelineContextSender *context) {
  if (context->manifest) {
    array_list_delete(context->manifest);
  }
@@ -53,11 +53,11 @@ void pipeline_context_sender_destroy(PipelineContextSender* context) {
  free(context);
 }

-PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue* queue,
+PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
+                                                          Queue *queue,
                                                          int file_descriptor) {
-  PipelineContextReceiver* context = malloc(sizeof(PipelineContextReceiver));
-  if (context == NULL)
-    return NULL;
+  PipelineContextReceiver *context = malloc(sizeof(PipelineContextReceiver));
+  if (context == NULL) return NULL;
  context->config = config;
  context->queue = queue;
  context->file_descriptor = file_descriptor;
@@ -72,7 +72,7 @@ PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue*
  return context;
 }

-void pipeline_context_receiver_destroy(PipelineContextReceiver* context) {
+void pipeline_context_receiver_destroy(PipelineContextReceiver *context) {
  config_delete(context->config);
  queue_destroy(context->queue);
  mtx_destroy(&context->mutex);
@@ -81,57 +81,57 @@ void pipeline_context_receiver_destroy(PipelineContextReceiver* context) {
  free(context);
 }

-static void receive_chunk_enqueue(int file_descriptor, PipelineContextReceiver* context) {
-  Chunk* chunk = receive_chunk_data(file_descriptor, context->config);
-  if (chunk == NULL)
-    return;
+static void receive_chunk_enqueue(int file_descriptor,
+                                  PipelineContextReceiver *context) {
+  Chunk *chunk = receive_chunk_data(file_descriptor, context->config);
+  if (chunk == NULL) return;

  for (int i = 0; i < chunk->element_count; i++) {
-    File* file = chunk->items[i];
+    File *file = chunk->items[i];
    chunk->items[i] = NULL;
    queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                &context->condition_not_empty, &context->condition_not_full);
+                                &context->condition_not_empty,
+                                &context->condition_not_full);
  }
  chunk_destroy(chunk);
 }

-int receive_thread(void* pipeline_context) {
-  PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
+int receive_thread(void *pipeline_context) {
+  PipelineContextReceiver *context =
+      (PipelineContextReceiver *)pipeline_context;
  mtx_lock(&context->mutex);
  int file_descriptor = context->file_descriptor;
-  const Config* config = context->config;
+  Config *config = context->config;
  mtx_unlock(&context->mutex);

  Status status;
-  if (!receive_status(file_descriptor, &status))
-    return thrd_error;
+  if (!receive_status(file_descriptor, &status)) return thrd_error;
  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
    if (status == STATUS_CHECK) {
      bool skipped;
-      File* file = receive_incremental_check(file_descriptor, config, &skipped);
+      File *file = receive_incremental_check(file_descriptor, config, &skipped);
      if (!skipped) {
-        if (file == NULL)
-          return thrd_error;
+        if (file == NULL) return thrd_error;
        queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                    &context->condition_not_empty, &context->condition_not_full);
+                                    &context->condition_not_empty,
+                                    &context->condition_not_full);
      }
    } else if (status == STATUS_CHUNK) {
      receive_chunk_enqueue(file_descriptor, context);
    } else {
-      File* file = file_receive(config, file_descriptor);
+      File *file = file_receive(config, file_descriptor);
      if (file) {
        queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                    &context->condition_not_empty, &context->condition_not_full);
+                                    &context->condition_not_empty,
+                                    &context->condition_not_full);
      } else {
        log_message(LOG_LEVEL_ERROR, "Failed to receive file");
      }
    }
-    if (!receive_status(file_descriptor, &status))
-      return thrd_error;
+    if (!receive_status(file_descriptor, &status)) return thrd_error;
  }
  if (status == STATUS_MANIFEST) {
-    if (receive_manifest(file_descriptor, config, &status) != 0)
-      return thrd_error;
+    if (receive_manifest(file_descriptor, config, &status) != 0) return thrd_error;
  }
  mtx_lock(&context->mutex);
  context->receiver_done = true;
@@ -140,17 +140,18 @@ int receive_thread(void* pipeline_context) {
  return thrd_success;
 }

-int write_thread(void* pipeline_context) {
-  PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
+int write_thread(void *pipeline_context) {
+  PipelineContextReceiver *context =
+      (PipelineContextReceiver *)pipeline_context;
  mtx_lock(&context->mutex);
  bool save_to_disk = context->config->save_to_disk;
-  char* root_directory = str_dup(context->config->receive_root_directory);
+  char *root_directory = str_dup(context->config->receive_root_directory);
  mtx_unlock(&context->mutex);

  while (true) {
-    File* file =
-        queue_dequeue_multithreaded(context->queue, &context->mutex, &context->condition_not_empty,
-                                    &context->condition_not_full, &context->receiver_done);
+    File *file = queue_dequeue_multithreaded(
+        context->queue, &context->mutex, &context->condition_not_empty,
+        &context->condition_not_full, &context->receiver_done);
    if (file == NULL) {
      free(root_directory);
      return thrd_success;
@@ -9,23 +9,23 @@
 #include "queue.h"

 typedef struct {
-  Config* config;
-  Queue* queue_scanner;
+  Config *config;
+  Queue *queue_scanner;
  mtx_t mutex_scanner;
  cnd_t condition_not_full_scanner;
  cnd_t condition_not_empty_scanner;
  bool scanner_done;
-  Queue* queue_loader;
+  Queue *queue_loader;
  mtx_t mutex_loader;
  cnd_t condition_not_full_loader;
  cnd_t condition_not_empty_loader;
  bool loader_done;
-  ArrayList* manifest;
+  ArrayList *manifest;
 } PipelineContextSender;

 typedef struct PipelineContextReceiver {
-  Queue* queue;
-  Config* config;
+  Queue *queue;
+  Config *config;
  int file_descriptor;
  mtx_t mutex;
  cnd_t condition_not_full;
@@ -33,12 +33,14 @@ typedef struct PipelineContextReceiver {
  bool receiver_done;
 } PipelineContextReceiver;

-PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
-                                                      Queue* queue_loader);
-void pipeline_context_sender_destroy(PipelineContextSender* context);
-PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue* queue_receiver,
+PipelineContextSender *pipeline_context_sender_create(Config *config,
+                                                      Queue *queue_scanner,
+                                                      Queue *queue_loader);
+void pipeline_context_sender_destroy(PipelineContextSender *context);
+PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
+                                                          Queue *queue_receiver,
                                                          int file_descriptor);
-void pipeline_context_receiver_destroy(PipelineContextReceiver* context);
-int receive_thread(void* pipeline_context);
-int write_thread(void* pipeline_context);
+void pipeline_context_receiver_destroy(PipelineContextReceiver *context);
+int receive_thread(void *pipeline_context);
+int write_thread(void *pipeline_context);
 #endif
@@ -10,7 +10,7 @@

 static __thread int io_read_fd = -1;
 static __thread int io_write_fd = -1;
-static SSL* io_ssl = NULL;
+static SSL *io_ssl = NULL;

 static unsigned long long io_bwlimit = 0;
 static long long bw_tokens = 0;
@@ -28,14 +28,13 @@ void io_set_bwlimit(unsigned long long bytes_per_sec) {
 }

 static void bw_throttle(size_t bytes_written) {
-  if (io_bwlimit == 0)
-    return;
+  if (io_bwlimit == 0) return;

  struct timespec now;
  clock_gettime(CLOCK_MONOTONIC, &now);

-  long long elapsed_ns =
-      (now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL + (now.tv_nsec - bw_last_refill.tv_nsec);
+  long long elapsed_ns = (now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL +
+                         (now.tv_nsec - bw_last_refill.tv_nsec);
  bw_last_refill = now;

  long long tokens_to_add = (long long)((double)io_bwlimit * elapsed_ns / 1000000000.0);
@@ -57,7 +56,7 @@ static void bw_throttle(size_t bytes_written) {
  }
 }

-void io_set_ssl(SSL* ssl) {
+void io_set_ssl(SSL *ssl) {
  io_ssl = ssl;
 }

@@ -65,19 +64,19 @@ static int io_fd(int dir_fd, int file_descriptor) {
  return (dir_fd != -1) ? dir_fd : file_descriptor;
 }

-bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
+bool send_n_data(int file_descriptor, void *data, size_t data_size) {
  log_message(LOG_LEVEL_DEBUG, "    Sending n Data: %zu", data_size);
  int fd = io_fd(io_write_fd, file_descriptor);
  ssize_t total_bytes_send = 0;
-  while ((size_t)total_bytes_send < data_size) {
+  while (total_bytes_send < data_size) {
    size_t chunk = data_size - total_bytes_send;
    if (io_bwlimit > 0 && chunk > 65536)
      chunk = 65536;
    ssize_t bytes_send;
    if (io_ssl)
-      bytes_send = SSL_write(io_ssl, (const char*)data + total_bytes_send, chunk);
+      bytes_send = SSL_write(io_ssl, (char *)data + total_bytes_send, chunk);
    else
-      bytes_send = write(fd, (const char*)data + total_bytes_send, chunk);
+      bytes_send = write(fd, (char *)data + total_bytes_send, chunk);
    if (bytes_send <= 0) {
      log_message(LOG_LEVEL_ERROR, "Could not send data");
      return false;
@@ -89,18 +88,18 @@ bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
  return true;
 }

-bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
+bool receive_n_data(int file_descriptor, void *data, size_t data_size) {
  log_message(LOG_LEVEL_DEBUG, "    Receiving n Data: %zu", data_size);
  int fd = io_fd(io_read_fd, file_descriptor);
  size_t total_bytes_received = 0;
  while (total_bytes_received < data_size) {
    ssize_t bytes_received;
    if (io_ssl)
-      bytes_received =
-          SSL_read(io_ssl, (char*)data + total_bytes_received, data_size - total_bytes_received);
+      bytes_received = SSL_read(io_ssl, (char *)data + total_bytes_received,
+                                data_size - total_bytes_received);
    else
-      bytes_received =
-          read(fd, (char*)data + total_bytes_received, data_size - total_bytes_received);
+      bytes_received = read(fd, (char *)data + total_bytes_received,
+                             data_size - total_bytes_received);
    if (bytes_received <= 0) {
      if (bytes_received == 0)
        log_message(LOG_LEVEL_ERROR, "Connection closed while receiving data");
@@ -114,7 +113,7 @@ bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
  return true;
 }

-static const char* status_to_string(Status status) {
+static const char *status_to_string(Status status) {
  switch (status) {
  case STATUS_OK:
    return "OK";
@@ -137,23 +136,19 @@ static const char* status_to_string(Status status) {
  }
 }

-bool send_str(int file_descriptor, const char* data) {
+bool send_str(int file_descriptor, char *data) {
  size_t size = strlen(data);
-  if (!send_n_data(file_descriptor, &size, sizeof(size_t)))
-    return false;
-  if (!send_n_data(file_descriptor, data, size))
-    return false;
+  if (!send_n_data(file_descriptor, &size, sizeof(size_t))) return false;
+  if (!send_n_data(file_descriptor, data, size)) return false;
  log_message(LOG_LEVEL_DEBUG, "Send String: %s", data);
  return true;
 }

-char* receive_str(int file_descriptor) {
+char *receive_str(int file_descriptor) {
  size_t size;
-  if (!receive_n_data(file_descriptor, &size, sizeof(size_t)))
-    return NULL;
-  char* data = (char*)malloc(size + 1);
-  if (data == NULL)
-    return NULL;
+  if (!receive_n_data(file_descriptor, &size, sizeof(size_t))) return NULL;
+  char *data = (char *)malloc(size + 1);
+  if (data == NULL) return NULL;
  if (!receive_n_data(file_descriptor, data, size)) {
    free(data);
    return NULL;
@@ -163,7 +158,7 @@ char* receive_str(int file_descriptor) {
  return data;
 }

-bool send_data(int file_descriptor, const Data* data) {
+bool send_data(int file_descriptor, Data *data) {
  unsigned long long data_size = data->size;
  if (!send_n_data(file_descriptor, &data_size, sizeof(unsigned long long)))
    return false;
@@ -173,13 +168,12 @@ bool send_data(int file_descriptor, const Data* data) {
  return true;
 }

-Data* receive_data(int file_descriptor) {
+Data *receive_data(int file_descriptor) {
  unsigned long long size = 0;
  if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
    return NULL;
-  void* data = malloc((size_t)size);
-  if (data == NULL)
-    return NULL;
+  void *data = malloc((size_t)size);
+  if (data == NULL) return NULL;
  if (!receive_n_data(file_descriptor, data, (size_t)size)) {
    free(data);
    return NULL;
@@ -189,29 +183,25 @@ Data* receive_data(int file_descriptor) {
 }

 bool send_int(int file_descriptor, int data) {
-  if (!send_n_data(file_descriptor, &data, sizeof(int)))
-    return false;
+  if (!send_n_data(file_descriptor, &data, sizeof(int))) return false;
  log_message(LOG_LEVEL_DEBUG, "Send Int: %d", data);
  return true;
 }

-bool receive_int(int file_descriptor, int* data) {
-  if (!receive_n_data(file_descriptor, data, sizeof(int)))
-    return false;
+bool receive_int(int file_descriptor, int *data) {
+  if (!receive_n_data(file_descriptor, data, sizeof(int))) return false;
  log_message(LOG_LEVEL_DEBUG, "Received Int: %d", *data);
  return true;
 }

 bool send_status(int file_descriptor, Status status) {
-  if (!send_n_data(file_descriptor, &status, sizeof(Status)))
-    return false;
+  if (!send_n_data(file_descriptor, &status, sizeof(Status))) return false;
  log_message(LOG_LEVEL_DEBUG, "Send Status: %s", status_to_string(status));
  return true;
 }

-bool receive_status(int file_descriptor, Status* status) {
-  if (!receive_n_data(file_descriptor, status, sizeof(Status)))
-    return false;
+bool receive_status(int file_descriptor, Status *status) {
+  if (!receive_n_data(file_descriptor, status, sizeof(Status))) return false;
  log_message(LOG_LEVEL_DEBUG, "Received Status: %s", status_to_string(*status));
  return true;
 }
@@ -8,31 +8,22 @@
 typedef struct ssl_st SSL;

 typedef int Status;
-enum NET_STATUS {
-  STATUS_OK,
-  STATUS_ERROR,
-  STATUS_FINISHED,
-  STATUS_NEXT,
-  STATUS_CHUNK,
-  STATUS_MANIFEST,
-  STATUS_CHECK,
-  STATUS_DELTA_SIGNATURE,
-  STATUS_DELTA_DATA
-};
+enum NET_STATUS { STATUS_OK, STATUS_ERROR, STATUS_FINISHED, STATUS_NEXT, STATUS_CHUNK, STATUS_MANIFEST, STATUS_CHECK, STATUS_DELTA_SIGNATURE, STATUS_DELTA_DATA };

 void io_set_fds(int read_fd, int write_fd);
 void io_set_bwlimit(unsigned long long bytes_per_sec);
-void io_set_ssl(SSL* ssl);
-bool send_n_data(int file_descriptor, const void* data, size_t data_size);
-bool receive_n_data(int file_descriptor, void* data, size_t data_size);
+typedef struct ssl_st SSL;
+void io_set_ssl(SSL *ssl);
+bool send_n_data(int file_descriptor, void *data, size_t data_size);
+bool receive_n_data(int file_descriptor, void *data, size_t data_size);

-bool send_str(int file_descriptor, const char* data);
-char* receive_str(int file_descriptor);
-bool send_data(int file_descriptor, const Data* data);
-Data* receive_data(int file_descriptor);
+bool send_str(int file_descriptor, char *data);
+char *receive_str(int file_descriptor);
+bool send_data(int file_descriptor, Data *data);
+Data *receive_data(int file_descriptor);
 bool send_int(int file_descriptor, int data);
-bool receive_int(int file_descriptor, int* data);
+bool receive_int(int file_descriptor, int *data);
 bool send_status(int file_descriptor, Status status);
-bool receive_status(int file_descriptor, Status* status);
+bool receive_status(int file_descriptor, Status *status);

 #endif
@@ -6,14 +6,14 @@

 #include "queue.h"

-Queue* queue_create(int capacity, void (*destroyer)(void* item)) {
-  Queue* queue = (Queue*)malloc(sizeof(Queue));
+Queue *queue_create(int capacity, void (*destroyer)(void *item)) {
+  Queue *queue = (Queue *)malloc(sizeof(Queue));
  if (queue == NULL) {
    perror("ERROR: Could not allocate memory for queue structure");
    return NULL;
  }

-  queue->items = malloc(capacity * sizeof(void*));
+  queue->items = malloc(capacity * sizeof(void *));
  if (queue->items == NULL) {
    free(queue);
    return NULL;
@@ -32,7 +32,7 @@ Queue* queue_create(int capacity, void (*destroyer)(void* item)) {
  return queue;
 }

-void queue_destroy(Queue* queue) {
+void queue_destroy(Queue *queue) {
  if (queue == NULL)
    return;

@@ -46,25 +46,24 @@ void queue_destroy(Queue* queue) {
  free(queue);
 }

-bool queue_is_empty(const Queue* queue) {
+bool queue_is_empty(Queue *queue) {
  if (queue == NULL)
    return true;
  return queue->size == 0;
 }

-bool queue_is_full(const Queue* queue) {
+bool queue_is_full(Queue *queue) {
  if (queue == NULL)
    return false;
  return queue->size == queue->capacity;
 }

-static bool queue_double_capacity(Queue* queue) {
-  if (queue == NULL)
-    return false;
+static bool queue_double_capacity(Queue *queue) {
+  if (queue == NULL) return false;
  unsigned int new_capacity = queue->capacity * 2;
  if (new_capacity <= 1)
    new_capacity = 100;
-  void** new_items = malloc(new_capacity * sizeof(void*));
+  void **new_items = malloc(new_capacity * sizeof(void *));
  if (new_items == NULL) {
    perror("ERROR: Could not allocate memory for doubling capacity of queue.");
    return false;
@@ -79,12 +78,10 @@ static bool queue_double_capacity(Queue* queue) {
  return true;
 }

-bool queue_enqueue(Queue* queue, void* item) {
-  if (queue == NULL || item == NULL)
-    return false;
+bool queue_enqueue(Queue *queue, void *item) {
+  if (queue == NULL || item == NULL) return false;
  if (queue_is_full(queue)) {
-    if (!queue_double_capacity(queue))
-      return false;
+    if (!queue_double_capacity(queue)) return false;
  }
  queue->items[queue->rear] = item;
  queue->rear = (queue->rear + 1) % queue->capacity;
@@ -92,8 +89,9 @@ bool queue_enqueue(Queue* queue, void* item) {
  return true;
 }

-bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
-                                 cnd_t* condition_not_full) {
+bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
+                                 cnd_t *condition_not_empty,
+                                 cnd_t *condition_not_full) {
  mtx_lock(mutex);
  while (queue_is_full(queue))
    cnd_wait(condition_not_full, mutex);
@@ -103,21 +101,23 @@ bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t*
  return ok;
 }

-void* queue_dequeue(Queue* queue) {
+void *queue_dequeue(Queue *queue) {
  if (queue == NULL || queue_is_empty(queue)) {
    perror("ERROR: Could not dequeue from null or empty queue.");
    return NULL;
  }

-  void* item = queue->items[queue->front];
+  void *item = queue->items[queue->front];
  queue->items[queue->front] = NULL;
  queue->front = (queue->front + 1) % queue->capacity;
  queue->size--;
  return item;
 }

-void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
-                                  cnd_t* condition_not_full, const bool* other_thread_done) {
+void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
+                                  cnd_t *condition_not_empty,
+                                  cnd_t *condition_not_full,
+                                  bool *other_thread_done) {
  mtx_lock(mutex);
  while (queue_is_empty(queue) && !*other_thread_done)
    cnd_wait(condition_not_empty, mutex);
@@ -125,7 +125,7 @@ void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_n
    mtx_unlock(mutex);
    return NULL;
  }
-  void* item = queue_dequeue(queue);
+  void *item = queue_dequeue(queue);
  cnd_signal(condition_not_full);
  mtx_unlock(mutex);
  return item;
@@ -5,23 +5,26 @@
 #include <threads.h>

 typedef struct Queue {
-  void** items;
+  void **items;
  int front;
  int rear;
  int size;
  int capacity;
-  void (*item_destroyer)(void* item);
+  void (*item_destroyer)(void *item);
 } Queue;

-Queue* queue_create(int capacity, void (*destroyer)(void* item));
-void queue_destroy(Queue* queue);
-bool queue_is_empty(const Queue* queue);
-bool queue_is_full(const Queue* queue);
-bool queue_enqueue(Queue* queue, void* item);
-bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
-                                 cnd_t* condition_not_full);
-void* queue_dequeue(Queue* queue);
-void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
-                                  cnd_t* condition_not_full, const bool* other_thread_done);
+Queue *queue_create(int capacity, void (*destroyer)(void *item));
+void queue_destroy(Queue *queue);
+bool queue_is_empty(Queue *queue);
+bool queue_is_full(Queue *queue);
+bool queue_enqueue(Queue *queue, void *item);
+bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
+                                 cnd_t *condition_not_empty,
+                                 cnd_t *condition_not_full);
+void *queue_dequeue(Queue *queue);
+void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
+                                  cnd_t *condition_not_empty,
+                                  cnd_t *condition_not_full,
+                                  bool *other_thread_done);

 #endif
@@ -13,41 +13,36 @@ typedef struct {
  char remote_path[4096];
 } RemoteDest;

-static int parse_remote_dest(const char* dest, RemoteDest* r) {
-  const char* colon = strchr(dest, ':');
-  if (!colon)
-    return -1;
+static int parse_remote_dest(const char *dest, RemoteDest *r) {
+  const char *colon = strchr(dest, ':');
+  if (!colon) return -1;

  size_t remote_path_len = strlen(colon + 1);
-  if (remote_path_len >= sizeof(r->remote_path))
-    return -1;
+  if (remote_path_len >= sizeof(r->remote_path)) return -1;
  memcpy(r->remote_path, colon + 1, remote_path_len + 1);

-  const char* at = memchr(dest, '@', colon - dest);
+  const char *at = memchr(dest, '@', colon - dest);
  if (at) {
    size_t user_len = at - dest;
-    if (user_len >= sizeof(r->user))
-      return -1;
+    if (user_len >= sizeof(r->user)) return -1;
    memcpy(r->user, dest, user_len);
    r->user[user_len] = '\0';

    size_t host_len = colon - at - 1;
-    if (host_len >= sizeof(r->host))
-      return -1;
+    if (host_len >= sizeof(r->host)) return -1;
    memcpy(r->host, at + 1, host_len);
    r->host[host_len] = '\0';
  } else {
    r->user[0] = '\0';
    size_t host_len = colon - dest;
-    if (host_len >= sizeof(r->host))
-      return -1;
+    if (host_len >= sizeof(r->host)) return -1;
    memcpy(r->host, dest, host_len);
    r->host[host_len] = '\0';
  }
  return 0;
 }

-Client* client_connect_ssh(const char* destination, int port) {
+Client *client_connect_ssh(char *destination, int port) {
  RemoteDest r;
  if (parse_remote_dest(destination, &r) != 0) {
    fprintf(stderr, "Invalid remote destination: %s\n", destination);
@@ -69,18 +64,15 @@ Client* client_connect_ssh(const char* destination, int port) {
  int exec_pipe[2];
  if (pipe(exec_pipe) < 0) {
    perror("pipe failed");
-    close(sv[0]);
-    close(sv[1]);
+    close(sv[0]); close(sv[1]);
    return NULL;
  }

  pid_t pid = fork();
  if (pid < 0) {
    perror("fork failed");
-    close(sv[0]);
-    close(sv[1]);
-    close(exec_pipe[0]);
-    close(exec_pipe[1]);
+    close(sv[0]); close(sv[1]);
+    close(exec_pipe[0]); close(exec_pipe[1]);
    return NULL;
  }

@@ -93,8 +85,7 @@ Client* client_connect_ssh(const char* destination, int port) {
      dup2(sv[1], STDIN_FILENO);
    if (sv[1] != STDOUT_FILENO)
      dup2(sv[1], STDOUT_FILENO);
-    if (sv[1] > 1)
-      close(sv[1]);
+    if (sv[1] > 1) close(sv[1]);

    char ssh_user[512];
    if (r.user[0] != '\0')
@@ -102,7 +93,7 @@ Client* client_connect_ssh(const char* destination, int port) {
    else
      snprintf(ssh_user, sizeof(ssh_user), "%s", r.host);

-    char* ssh_argv[16];
+    char *ssh_argv[16];
    int ac = 0;
    char port_str[16];
    ssh_argv[ac++] = "ssh";
@@ -142,7 +133,7 @@ Client* client_connect_ssh(const char* destination, int port) {
    return NULL;
  }

-  Client* client = malloc(sizeof(Client));
+  Client *client = malloc(sizeof(Client));
  if (client == NULL) {
    close(sv[0]);
    waitpid(pid, NULL, 0);
@@ -3,6 +3,6 @@

 #include "transport_tcp.h"

-Client* client_connect_ssh(const char* destination, int port);
+Client *client_connect_ssh(char *destination, int port);

 #endif
@@ -11,8 +11,8 @@
 #include <sys/wait.h>
 #include <unistd.h>

-Server* server_create(int port) {
-  Server* server = (Server*)malloc(sizeof(Server));
+Server *server_create(int port) {
+  Server *server = (Server *)malloc(sizeof(Server));
  if (server == NULL) {
    perror("Could not allocate space for Server");
    return NULL;
@@ -26,7 +26,8 @@ Server* server_create(int port) {
  }
  server->file_descriptor = file_descriptor;
  int opt = 1;
-  if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
+  if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt,
+                 sizeof(opt))) {
    perror("Error setting a socket option!");
    close(server->file_descriptor);
    free(server);
@@ -39,8 +40,8 @@ Server* server_create(int port) {
  server->address_length = sizeof(server->address);
  server->ssl_ctx = NULL;

-  if (bind(server->file_descriptor, (struct sockaddr*)&server->address, server->address_length) <
-      0) {
+  if (bind(server->file_descriptor, (struct sockaddr *)&server->address,
+           server->address_length) < 0) {
    perror("Could not bind server");
    close(server->file_descriptor);
    free(server);
@@ -50,9 +51,8 @@ Server* server_create(int port) {
  return server;
 }

-void server_delete(Server** server) {
-  if (server == NULL || *server == NULL)
-    return;
+void server_delete(Server **server) {
+  if (server == NULL || *server == NULL) return;
  close((*server)->file_descriptor);
  if ((*server)->ssl_ctx) {
    SSL_CTX_free((*server)->ssl_ctx);
@@ -62,8 +62,8 @@ void server_delete(Server** server) {
  *server = NULL;
 }

-static void accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
-                        const char* log_fmt) {
+static void accept_loop(Server *server, void (*child_fn)(int, void *),
+                        void *child_ctx, const char *log_fmt) {
  if (listen(server->file_descriptor, SOMAXCONN) < 0) {
    perror("Could not listen on port!");
    return;
@@ -72,7 +72,8 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
  while (1) {
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
-    int fd = accept(server->file_descriptor, (struct sockaddr*)&client_addr, &client_len);
+    int fd = accept(server->file_descriptor, (struct sockaddr *)&client_addr,
+                    &client_len);
    if (fd < 0) {
      perror("Could not accept the connection");
      continue;
@@ -89,35 +90,35 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
  }
 }

-struct plain_ctx {
-  void (*handler)(int);
-};
+struct plain_ctx { void (*handler)(int); };

-static void plain_child_fn(int fd, void* ctx) {
-  ((struct plain_ctx*)ctx)->handler(fd);
+static void plain_child_fn(int fd, void *ctx) {
+  ((struct plain_ctx *)ctx)->handler(fd);
 }

-bool server_listen(Server* server, void (*handler)(int file_descriptor)) {
-  log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d", ntohs(server->address.sin_port));
+bool server_listen(Server *server, void (*handler)(int file_descriptor)) {
+  log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d",
+              ntohs(server->address.sin_port));
  struct plain_ctx ctx = {handler};
  accept_loop(server, plain_child_fn, &ctx, "Received Connection");
  return true;
 }

-void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
-                        const char* log_fmt) {
-  log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d", ntohs(server->address.sin_port));
+void server_accept_loop(Server *server, void (*child_fn)(int, void *),
+                        void *child_ctx, const char *log_fmt) {
+  log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d",
+              ntohs(server->address.sin_port));
  accept_loop(server, child_fn, child_ctx, log_fmt);
 }

-Client* client_create() {
+Client *client_create() {
  int file_descriptor = socket(AF_INET, SOCK_STREAM, 0);
  if (file_descriptor < 0) {
    perror("Could not create Socket!");
    return NULL;
  }

-  Client* client = (Client*)malloc(sizeof(Client));
+  Client *client = (Client *)malloc(sizeof(Client));
  if (client == NULL) {
    close(file_descriptor);
    return NULL;
@@ -131,7 +132,7 @@ Client* client_create() {
  return client;
 }

-bool client_connect(Client* client, char* host, int port) {
+bool client_connect(Client *client, char *host, int port) {
  client->address.sin_port = htons(port);

  if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
@@ -139,15 +140,15 @@ bool client_connect(Client* client, char* host, int port) {
    return false;
  }

-  if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
-      0) {
+  if (connect(client->file_descriptor, (struct sockaddr *)&client->address,
+              client->address_length) < 0) {
    perror("Could not connect to Server!");
    return false;
  }
  return true;
 }

-void client_disconnect(Client* client) {
+void client_disconnect(Client *client) {
  if (client->ssl) {
    SSL_shutdown(client->ssl);
    SSL_free(client->ssl);
@@ -162,9 +163,8 @@ void client_disconnect(Client* client) {
  }
 }

-void client_delete(Client* client) {
-  if (client == NULL)
-    return;
+void client_delete(Client *client) {
+  if (client == NULL) return;
  if (client->ssl_ctx) {
    SSL_CTX_free(client->ssl_ctx);
    client->ssl_ctx = NULL;
@@ -9,7 +9,7 @@ typedef struct Server {
  struct sockaddr_in address;
  unsigned int address_length;
  int file_descriptor;
-  void* ssl_ctx;
+  void *ssl_ctx;
 } Server;

 typedef struct Client {
@@ -17,18 +17,18 @@ typedef struct Client {
  unsigned int address_length;
  int file_descriptor;
  pid_t ssh_child_pid;
-  void* ssl;
-  void* ssl_ctx;
+  void *ssl;
+  void *ssl_ctx;
 } Client;

-Server* server_create(int port);
-bool server_listen(Server* server, void (*handler)(int file_descriptor));
-void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
-                        const char* log_fmt);
-void server_delete(Server** server);
-Client* client_create();
-bool client_connect(Client* client, char* host, int port);
-void client_disconnect(Client* client);
-void client_delete(Client* client);
+Server *server_create(int port);
+bool server_listen(Server *server, void (*handler)(int file_descriptor));
+void server_accept_loop(Server *server, void (*child_fn)(int, void *),
+                        void *child_ctx, const char *log_fmt);
+void server_delete(Server **server);
+Client *client_create();
+bool client_connect(Client *client, char *host, int port);
+void client_disconnect(Client *client);
+void client_delete(Client *client);

 #endif
@@ -31,10 +31,11 @@ static void log_ssl_errors(void) {
  }
 }

-static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key,
-                               const char* ca_path) {
-  const SSL_METHOD* method = is_server ? TLS_server_method() : TLS_client_method();
-  SSL_CTX* ctx = SSL_CTX_new(method);
+static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
+                                const char *key, const char *ca_path) {
+  const SSL_METHOD *method =
+      is_server ? TLS_server_method() : TLS_client_method();
+  SSL_CTX *ctx = SSL_CTX_new(method);
  if (!ctx) {
    log_message(LOG_LEVEL_ERROR, "Unable to create SSL context");
    log_ssl_errors();
@@ -57,7 +58,8 @@ static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key
      return NULL;
    }
    if (!SSL_CTX_check_private_key(ctx)) {
-      log_message(LOG_LEVEL_ERROR, "Private key does not match certificate");
+      log_message(LOG_LEVEL_ERROR,
+                  "Private key does not match certificate");
      SSL_CTX_free(ctx);
      return NULL;
    }
@@ -77,8 +79,8 @@ static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key
  return ctx;
 }

-static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) {
-  SSL* ssl = SSL_new(ctx);
+static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
+  SSL *ssl = SSL_new(ctx);
  if (!ssl) {
    log_message(LOG_LEVEL_ERROR, "Failed to create SSL object");
    return NULL;
@@ -91,7 +93,8 @@ static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) {
    ret = SSL_connect(ssl);

  if (ret <= 0) {
-    log_message(LOG_LEVEL_ERROR, "SSL %s failed", is_server ? "accept" : "connect");
+    log_message(LOG_LEVEL_ERROR, "SSL %s failed",
+                is_server ? "accept" : "connect");
    log_ssl_errors();
    SSL_free(ssl);
    return NULL;
@@ -99,25 +102,23 @@ static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) {
  return ssl;
 }

-bool server_create_tls(Server* server, const char* cert_path, const char* key_path,
-                       const char* ca_path) {
-  SSL_CTX* ctx = create_ssl_ctx(true, cert_path, key_path, ca_path);
-  if (!ctx)
-    return false;
+bool server_create_tls(Server *server, const char *cert_path,
+                        const char *key_path, const char *ca_path) {
+  SSL_CTX *ctx = create_ssl_ctx(true, cert_path, key_path, ca_path);
+  if (!ctx) return false;
  server->ssl_ctx = ctx;
  return true;
 }

 struct tls_child_ctx {
  void (*handler)(int);
-  SSL_CTX* ssl_ctx;
+  SSL_CTX *ssl_ctx;
 };

-static void tls_child_fn(int fd, void* arg) {
-  struct tls_child_ctx* ctx = (struct tls_child_ctx*)arg;
-  SSL* ssl = wrap_fd_with_ssl(fd, ctx->ssl_ctx, true);
-  if (!ssl)
-    return;
+static void tls_child_fn(int fd, void *arg) {
+  struct tls_child_ctx *ctx = (struct tls_child_ctx *)arg;
+  SSL *ssl = wrap_fd_with_ssl(fd, ctx->ssl_ctx, true);
+  if (!ssl) return;
  io_set_ssl(ssl);
  ctx->handler(fd);
  SSL_shutdown(ssl);
@@ -125,31 +126,31 @@ static void tls_child_fn(int fd, void* arg) {
  io_set_ssl(NULL);
 }

-bool server_listen_tls(Server* server, void (*handler)(int file_descriptor)) {
-  struct tls_child_ctx ctx = {handler, (SSL_CTX*)server->ssl_ctx};
+bool server_listen_tls(Server *server, void (*handler)(int file_descriptor)) {
+  struct tls_child_ctx ctx = {handler, (SSL_CTX *)server->ssl_ctx};
  server_accept_loop(server, tls_child_fn, &ctx, "Received TLS Connection");
  return true;
 }

-bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
-                        const char* key_path, const char* ca_path) {
+bool client_connect_tls(Client *client, char *host, int port,
+                         const char *cert_path, const char *key_path,
+                         const char *ca_path) {
  client->address.sin_port = htons(port);
  if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
    perror("Could not convert host address!");
    return false;
  }
-  if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
-      0) {
+  if (connect(client->file_descriptor, (struct sockaddr *)&client->address,
+               client->address_length) < 0) {
    perror("Could not connect to Server!");
    return false;
  }

-  SSL_CTX* ctx = create_ssl_ctx(false, cert_path, key_path, ca_path);
-  if (!ctx)
-    return false;
+  SSL_CTX *ctx = create_ssl_ctx(false, cert_path, key_path, ca_path);
+  if (!ctx) return false;
  client->ssl_ctx = ctx;

-  SSL* ssl = wrap_fd_with_ssl(client->file_descriptor, ctx, false);
+  SSL *ssl = wrap_fd_with_ssl(client->file_descriptor, ctx, false);
  if (!ssl) {
    SSL_CTX_free(ctx);
    client->ssl_ctx = NULL;
@@ -6,10 +6,11 @@

 bool tls_global_init(void);

-bool server_create_tls(Server* server, const char* cert_path, const char* key_path,
-                       const char* ca_path);
-bool server_listen_tls(Server* server, void (*handler)(int file_descriptor));
-bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
-                        const char* key_path, const char* ca_path);
+bool server_create_tls(Server *server, const char *cert_path,
+                        const char *key_path, const char *ca_path);
+bool server_listen_tls(Server *server, void (*handler)(int file_descriptor));
+bool client_connect_tls(Client *client, char *host, int port,
+                         const char *cert_path, const char *key_path,
+                         const char *ca_path);

 #endif
@@ -8,25 +8,21 @@
 #include <sys/stat.h>
 #include <unistd.h>

-bool mkdir_r(const char* path) {
-  char* path_duplicate = malloc(strlen(path) + 1);
-  if (!path_duplicate)
-    return false;
+bool mkdir_r(char *path) {
+  char *path_duplicate = malloc(strlen(path) + 1);
+  if (!path_duplicate) return false;
  strcpy(path_duplicate, path);
-  char* path_current = (char*)malloc((strlen(path) + 2) * sizeof(char));
-  if (!path_current) {
-    free(path_duplicate);
-    return false;
-  }
-  char* path_current_position = path_current;
+  char *path_current = (char *)malloc((strlen(path) + 2) * sizeof(char));
+  if (!path_current) { free(path_duplicate); return false; }
+  char *path_current_position = path_current;
  if (path[0] == '/') {
    strcpy(path_current, "/");
    path_current_position += 1;
  } else {
    path_current[0] = '\0';
  }
-  const char* delimiter = "/";
-  const char* part = strtok(path_duplicate, delimiter);
+  const char *delimiter = "/";
+  char *part = strtok(path_duplicate, delimiter);
  bool ok = true;
  while (part != NULL) {
    strcpy(path_current_position, part);
@@ -48,15 +44,15 @@ bool mkdir_r(const char* path) {
  return ok;
 }

-char* str_dup(const char* string) {
+char *str_dup(const char *string) {
  if (string == NULL)
    return NULL;
-  char* new_string = (char*)malloc(strlen(string) + 1);
+  char *new_string = (char *)malloc(strlen(string) + 1);
  strcpy(new_string, string);
  return new_string;
 }

-bool glob_match(const char* pattern, const char* str) {
+bool glob_match(const char *pattern, const char *str) {
  while (*pattern) {
    if (*pattern == '*') {
      pattern++;
@@ -81,16 +77,17 @@ bool glob_match(const char* pattern, const char* str) {
  return *str == '\0';
 }

-static void delete_extras_walk(const char* abs_path, const char* rel_path, ArrayList* manifest) {
-  DIR* dir = opendir(abs_path);
+static void delete_extras_walk(const char *abs_path, const char *rel_path,
+                               ArrayList *manifest) {
+  DIR *dir = opendir(abs_path);
  if (!dir)
    return;
-  struct dirent* entry;
+  struct dirent *entry;
  while ((entry = readdir(dir)) != NULL) {
    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
      continue;
-    char* child_abs = path_cat((char*)abs_path, entry->d_name);
-    char* child_rel = path_cat((char*)rel_path, entry->d_name);
+    char *child_abs = path_cat((char *)abs_path, entry->d_name);
+    char *child_rel = path_cat((char *)rel_path, entry->d_name);
    struct stat st;
    if (stat(child_abs, &st) != 0) {
      free(child_abs);
@@ -103,7 +100,7 @@ static void delete_extras_walk(const char* abs_path, const char* rel_path, Array
      // Check if relative path is in manifest
      bool found = false;
      for (int i = 0; i < manifest->size; i++) {
-        if (strcmp((char*)manifest->items[i], child_rel) == 0) {
+        if (strcmp((char *)manifest->items[i], child_rel) == 0) {
          found = true;
          break;
        }
@@ -120,27 +117,26 @@ static void delete_extras_walk(const char* abs_path, const char* rel_path, Array
  rmdir(abs_path);
 }

-void delete_extras(const char* dest_root, ArrayList* manifest) {
+void delete_extras(const char *dest_root, ArrayList *manifest) {
  delete_extras_walk(dest_root, "", manifest);
 }

-char* path_cat(const char* path1, char* path2) {
+char *path_cat(char *path1, char *path2) {
  if (path1 == NULL || *path1 == '\0')
    return str_dup(path2);
  if (path2 == NULL || *path2 == '\0')
    return str_dup(path1);
  int path1_len = strlen(path1);
  int path2_len = strlen(path2);
-  char* path2_pointer = path2;
+  char *path2_pointer = path2;
  if (path1[path1_len - 1] == '/')
    path1_len -= 1;
  if (path2[0] == '/') {
    path2_pointer += 1;
    path2_len -= 1;
  }
-  char* new_path = malloc(path1_len + path2_len + 2);
-  if (new_path == NULL)
-    return NULL;
+  char *new_path = malloc(path1_len + path2_len + 2);
+  if (new_path == NULL) return NULL;
  memcpy(new_path, path1, path1_len);
  new_path[path1_len] = '/';
  memcpy(new_path + path1_len + 1, path2_pointer, path2_len);
@@ -4,10 +4,10 @@
 #include "array_list.h"
 #include <stdbool.h>

-bool mkdir_r(const char* path);
-char* str_dup(const char* string);
-char* path_cat(const char* path1, char* path2);
-bool glob_match(const char* pattern, const char* str);
-void delete_extras(const char* dest_root, ArrayList* manifest);
+bool mkdir_r(char *path);
+char *str_dup(const char *string);
+char *path_cat(char *path1, char *path2);
+bool glob_match(const char *pattern, const char *str);
+void delete_extras(const char *dest_root, ArrayList *manifest);

 #endif
@@ -4,28 +4,28 @@
 #include <stdlib.h>

 static int destroyer_calls = 0;
-static void test_destroyer(void* item) {
+static void test_destroyer(void *item) {
  destroyer_calls++;
  free(item);
 }

 void test_array_list() {
-  ArrayList* list = array_list_create(free);
+  ArrayList *list = array_list_create(free);
  EXPECT_NOT_NULL(list);
  EXPECT_EQ_INT(list->size, 0);
  EXPECT_EQ_INT(list->capacity, 100);

  // Test adding
-  int* val1 = malloc(sizeof(int));
+  int *val1 = malloc(sizeof(int));
  *val1 = 42;
  array_list_add(list, val1);
  EXPECT_EQ_INT(list->size, 1);
-  EXPECT_EQ_INT(*(int*)list->items[0], 42);
+  EXPECT_EQ_INT(*(int *)list->items[0], 42);

  // Test extending capacity
  // Initial capacity is 100. Let's add 105 elements.
  for (int i = 0; i < 105; i++) {
-    int* val = malloc(sizeof(int));
+    int *val = malloc(sizeof(int));
    *val = i;
    array_list_add(list, val);
  }
@@ -33,15 +33,15 @@ void test_array_list() {
  EXPECT_EQ_INT(list->capacity, 200); // 100 * 2

  // Verify contents
-  EXPECT_EQ_INT(*(int*)list->items[0], 42);
-  EXPECT_EQ_INT(*(int*)list->items[1], 0);
-  EXPECT_EQ_INT(*(int*)list->items[105], 104);
+  EXPECT_EQ_INT(*(int *)list->items[0], 42);
+  EXPECT_EQ_INT(*(int *)list->items[1], 0);
+  EXPECT_EQ_INT(*(int *)list->items[105], 104);

  // Test array conversion
-  void** arr = array_list_to_array(list);
+  void **arr = array_list_to_array(list);
  EXPECT_NOT_NULL(arr);
-  EXPECT_EQ_INT(*(int*)arr[0], 42);
-  EXPECT_EQ_INT(*(int*)arr[105], 104);
+  EXPECT_EQ_INT(*(int *)arr[0], 42);
+  EXPECT_EQ_INT(*(int *)arr[105], 104);
  free(arr);

  // Delete list, verifying the destroyer is called 106 times
@@ -7,13 +7,13 @@
 #include <unistd.h>

 static void test_file_operations() {
-  char* test_path = "temp_file_test.txt";
-  char* test_content = "Hello, Chunk System!";
+  char *test_path = "temp_file_test.txt";
+  char *test_content = "Hello, Chunk System!";
  unsigned long long test_len = strlen(test_content);

  to_disk(test_path, test_content, test_len);

-  File* f = file_create(test_path);
+  File *f = file_create(test_path);
  EXPECT_NOT_NULL(f);
  EXPECT_EQ_STR(f->path, test_path);
  EXPECT_NOT_NULL(f->data);
@@ -35,12 +35,12 @@ static void test_file_operations() {
 }

 static void test_chunk_operations() {
-  char* path1 = "temp_chunk_1.txt";
-  char* content1 = "chunk item 1";
+  char *path1 = "temp_chunk_1.txt";
+  char *content1 = "chunk item 1";
  unsigned long long len1 = strlen(content1);

-  char* path2 = "temp_chunk_2.txt";
-  char* content2 = "chunk item number 2";
+  char *path2 = "temp_chunk_2.txt";
+  char *content2 = "chunk item number 2";
  unsigned long long len2 = strlen(content2);

  to_disk(path1, content1, len1);
@@ -50,13 +50,13 @@ static void test_chunk_operations() {
  stat(path1, &st1);
  stat(path2, &st2);

-  File* f1 = file_create(path1);
+  File *f1 = file_create(path1);
  f1->data->size = st1.st_size;
-  File* f2 = file_create(path2);
+  File *f2 = file_create(path2);
  f2->data->size = st2.st_size;

-  File* files[2] = {f1, f2};
-  Chunk* chunk = chunk_create(files, 2);
+  File *files[2] = {f1, f2};
+  Chunk *chunk = chunk_create(files, 2);
  EXPECT_NOT_NULL(chunk);
  EXPECT_EQ_INT(chunk->element_count, 2);
  EXPECT_NOT_NULL(chunk->items[0]);
@@ -67,10 +67,10 @@ static void test_chunk_operations() {
  file_load_data(f2);

  // Test chunk_serialize / chunk_deserialize round-trip
-  Data* serialized = chunk_serialize(chunk, false);
+  Data *serialized = chunk_serialize(chunk, false);
  EXPECT_NOT_NULL(serialized);

-  Chunk* deserialized = chunk_deserialize(serialized, false);
+  Chunk *deserialized = chunk_deserialize(serialized, false);
  EXPECT_NOT_NULL(deserialized);
  EXPECT_EQ_INT(deserialized->element_count, 2);
  EXPECT_EQ_STR(deserialized->items[0]->path, path1);
@@ -9,18 +9,18 @@
 #include <unistd.h>

 static void test_data_compress_decompress_roundtrip() {
-  const char original[] = "Hello, World! This is test data for compression round-trip!";
+  char original[] = "Hello, World! This is test data for compression round-trip!";
  size_t len = strlen(original);

-  char* buf = malloc(len);
+  char *buf = malloc(len);
  memcpy(buf, original, len);
-  Data* original_data = data_create(buf, len);
+  Data *original_data = data_create(buf, len);
  EXPECT_NOT_NULL(original_data);

-  Data* compressed = data_compress(original_data, 3);
+  Data *compressed = data_compress(original_data, 3);
  EXPECT_NOT_NULL(compressed);

-  Data* decompressed = data_decompress(compressed);
+  Data *decompressed = data_decompress(compressed);
  EXPECT_NOT_NULL(decompressed);
  EXPECT_EQ_INT((int)decompressed->size, (int)len);
  EXPECT_EQ_INT(memcmp(decompressed->data, original, len), 0);
@@ -32,18 +32,18 @@ static void test_data_compress_decompress_roundtrip() {

 static void test_data_compress_decompress_large() {
  size_t size = 1024 * 10;
-  char* original = malloc(size);
+  char *original = malloc(size);
  EXPECT_NOT_NULL(original);
  for (size_t i = 0; i < size; i++)
    original[i] = (char)(i % 256);

-  Data* original_data = data_create(original, size);
+  Data *original_data = data_create(original, size);
  EXPECT_NOT_NULL(original_data);

-  Data* compressed = data_compress(original_data, 1);
+  Data *compressed = data_compress(original_data, 1);
  EXPECT_NOT_NULL(compressed);

-  Data* decompressed = data_decompress(compressed);
+  Data *decompressed = data_decompress(compressed);
  EXPECT_NOT_NULL(decompressed);
  EXPECT_EQ_INT((int)decompressed->size, (int)size);
  EXPECT_EQ_INT(memcmp(decompressed->data, original, size), 0);
@@ -54,12 +54,12 @@ static void test_data_compress_decompress_large() {
 }

 static void test_chunk_compress_decompress_roundtrip() {
-  char* path1 = "temp_comp_test_1.txt";
-  char* content1 = "chunk compression test file 1";
+  char *path1 = "temp_comp_test_1.txt";
+  char *content1 = "chunk compression test file 1";
  unsigned long long len1 = strlen(content1);

-  char* path2 = "temp_comp_test_2.txt";
-  char* content2 = "chunk compression test file 2 with more data";
+  char *path2 = "temp_comp_test_2.txt";
+  char *content2 = "chunk compression test file 2 with more data";
  unsigned long long len2 = strlen(content2);

  to_disk(path1, content1, len1);
@@ -69,9 +69,9 @@ static void test_chunk_compress_decompress_roundtrip() {
  EXPECT_EQ_INT(stat(path1, &st1), 0);
  EXPECT_EQ_INT(stat(path2, &st2), 0);

-  File* f1 = file_create(path1);
+  File *f1 = file_create(path1);
  f1->data->size = st1.st_size;
-  File* f2 = file_create(path2);
+  File *f2 = file_create(path2);
  f2->data->size = st2.st_size;
  EXPECT_NOT_NULL(f1);
  EXPECT_NOT_NULL(f2);
@@ -79,17 +79,17 @@ static void test_chunk_compress_decompress_roundtrip() {
  file_load_data(f1);
  file_load_data(f2);

-  File* files[2] = {f1, f2};
-  Chunk* chunk = chunk_create(files, 2);
+  File *files[2] = {f1, f2};
+  Chunk *chunk = chunk_create(files, 2);
  EXPECT_NOT_NULL(chunk);

-  Data* compressed = chunk_compress(chunk, 3, false);
+  Data *compressed = chunk_compress(chunk, 3, false);
  EXPECT_NOT_NULL(compressed);

-  Data* decompressed_data = data_decompress(compressed);
+  Data *decompressed_data = data_decompress(compressed);
  EXPECT_NOT_NULL(decompressed_data);

-  Chunk* decompressed_chunk = chunk_deserialize(decompressed_data, false);
+  Chunk *decompressed_chunk = chunk_deserialize(decompressed_data, false);
  EXPECT_NOT_NULL(decompressed_chunk);
  EXPECT_EQ_INT(decompressed_chunk->element_count, 2);

@@ -7,8 +7,8 @@
 #include <stdlib.h>

 static void test_config_lifecycle() {
-  Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/dst"), true, true, false,
-                              false, false, 1, false, 0);
+  Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/dst"),
+                              true, true, false, false, false, 1, false, 0);
  EXPECT_NOT_NULL(cfg);
  EXPECT_EQ_STR(cfg->version, "1.0");
  EXPECT_EQ_STR(cfg->send_directory, "/src");
@@ -23,8 +23,8 @@ static void test_config_lifecycle() {
 }

 static void test_config_ssh_dest() {
-  Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("user@host:/dst"), true,
-                              false, false, false, false, 1, false, 0);
+  Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("user@host:/dst"),
+                              true, false, false, false, false, 1, false, 0);
  EXPECT_NOT_NULL(cfg);
  EXPECT_EQ_INT(cfg->transport, TRANSPORT_TCP);
  EXPECT_NULL(cfg->ssh_destination);
@@ -38,8 +38,8 @@ static void test_config_ssh_dest() {
 }

 static void test_config_ssh_dest_local_path() {
-  Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/local/path"), true, false,
-                              false, false, false, 1, false, 0);
+  Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/local/path"),
+                              true, false, false, false, false, 1, false, 0);
  config_parse_ssh_dest(cfg);
  EXPECT_EQ_INT(cfg->transport, TRANSPORT_TCP);
  EXPECT_NULL(cfg->ssh_destination);
@@ -48,8 +48,8 @@ static void test_config_ssh_dest_local_path() {
 }

 static void test_config_ssh_dest_no_user() {
-  Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("host:/remote"), true, false,
-                              false, false, false, 1, false, 0);
+  Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("host:/remote"),
+                              true, false, false, false, false, 1, false, 0);
  config_parse_ssh_dest(cfg);
  EXPECT_EQ_INT(cfg->transport, TRANSPORT_SSH);
  EXPECT_EQ_STR(cfg->ssh_destination, "host:/remote");
@@ -58,12 +58,12 @@ static void test_config_ssh_dest_no_user() {
 }

 static void test_pipeline_sender_lifecycle() {
-  Config* cfg = config_create(str_dup("2.0"), str_dup("/src2"), str_dup("/dst2"), false, false,
-                              true, true, false, 1, false, 0);
-  Queue* q1 = queue_create(5, NULL);
-  Queue* q2 = queue_create(15, NULL);
+  Config *cfg = config_create(str_dup("2.0"), str_dup("/src2"),
+                              str_dup("/dst2"), false, false, true, true, false, 1, false, 0);
+  Queue *q1 = queue_create(5, NULL);
+  Queue *q2 = queue_create(15, NULL);

-  PipelineContextSender* pcs = pipeline_context_sender_create(cfg, q1, q2);
+  PipelineContextSender *pcs = pipeline_context_sender_create(cfg, q1, q2);
  EXPECT_NOT_NULL(pcs);
  EXPECT_EQ_STR(pcs->config->version, "2.0");
  EXPECT_EQ_INT(pcs->queue_scanner->capacity, 5);
@@ -75,11 +75,11 @@ static void test_pipeline_sender_lifecycle() {
 }

 static void test_pipeline_receiver_lifecycle() {
-  Config* cfg = config_create(str_dup("3.0"), str_dup("/src3"), str_dup("/dst3"), true, true, true,
-                              true, false, 1, false, 0);
-  Queue* q = queue_create(20, NULL);
+  Config *cfg = config_create(str_dup("3.0"), str_dup("/src3"),
+                              str_dup("/dst3"), true, true, true, true, false, 1, false, 0);
+  Queue *q = queue_create(20, NULL);

-  PipelineContextReceiver* pcr = pipeline_context_receiver_create(cfg, q, 42);
+  PipelineContextReceiver *pcr = pipeline_context_receiver_create(cfg, q, 42);
  EXPECT_NOT_NULL(pcr);
  EXPECT_EQ_STR(pcr->config->version, "3.0");
  EXPECT_EQ_INT(pcr->queue->capacity, 20);
@@ -4,7 +4,7 @@
 #include <stdlib.h>

 static void test_adler32_basic() {
-  const char* data = "Hello";
+  const char *data = "Hello";
  uint32_t h = delta_adler32(data, 5);
  EXPECT_TRUE(h != 0);
  uint32_t h2 = delta_adler32(data, 5);
@@ -12,15 +12,15 @@ static void test_adler32_basic() {
 }

 static void test_adler32_different_data() {
-  const char* a = "AAAA";
-  const char* b = "BBBB";
+  const char *a = "AAAA";
+  const char *b = "BBBB";
  uint32_t ha = delta_adler32(a, 4);
  uint32_t hb = delta_adler32(b, 4);
  EXPECT_TRUE(ha != hb);
 }

 static void test_xxhash32_basic() {
-  const char* data = "Hello";
+  const char *data = "Hello";
  uint32_t h = delta_xxhash32(data, 5);
  EXPECT_TRUE(h != 0);
  uint32_t h2 = delta_xxhash32(data, 5);
@@ -28,8 +28,8 @@ static void test_xxhash32_basic() {
 }

 static void test_xxhash32_different_data() {
-  const char* a = "AAAA";
-  const char* b = "BBBB";
+  const char *a = "AAAA";
+  const char *b = "BBBB";
  uint32_t ha = delta_xxhash32(a, 4);
  uint32_t hb = delta_xxhash32(b, 4);
  EXPECT_TRUE(ha != hb);
@@ -37,18 +37,17 @@ static void test_xxhash32_different_data() {

 static void test_signature_roundtrip() {
  char old_data[4096];
-  for (int i = 0; i < 4096; i++)
-    old_data[i] = (char)(i % 256);
+  for (int i = 0; i < 4096; i++) old_data[i] = (char)(i % 256);

-  DeltaSignature* sig = delta_signature_create(old_data, 4096, 1024);
+  DeltaSignature *sig = delta_signature_create(old_data, 4096, 1024);
  EXPECT_NOT_NULL(sig);
  EXPECT_EQ_INT((int)sig->block_count, 4);
  EXPECT_EQ_INT((int)sig->block_size, 1024);

-  Data* serialized = delta_signature_serialize(sig);
+  Data *serialized = delta_signature_serialize(sig);
  EXPECT_NOT_NULL(serialized);

-  DeltaSignature* deserialized = delta_signature_deserialize(serialized);
+  DeltaSignature *deserialized = delta_signature_deserialize(serialized);
  EXPECT_NOT_NULL(deserialized);
  EXPECT_EQ_INT((int)deserialized->block_count, (int)sig->block_count);
  EXPECT_EQ_INT((int)deserialized->block_size, (int)sig->block_size);
@@ -65,13 +64,12 @@ static void test_signature_roundtrip() {

 static void test_delta_identical_files() {
  char data[2048];
-  for (int i = 0; i < 2048; i++)
-    data[i] = (char)(i % 128);
+  for (int i = 0; i < 2048; i++) data[i] = (char)(i % 128);

-  DeltaSignature* sig = delta_signature_create(data, 2048, 512);
+  DeltaSignature *sig = delta_signature_create(data, 2048, 512);
  EXPECT_NOT_NULL(sig);

-  Delta* delta = delta_compute(data, 2048, sig, 512);
+  Delta *delta = delta_compute(data, 2048, sig, 512);
  EXPECT_NOT_NULL(delta);

  bool has_match = false;
@@ -107,10 +105,10 @@ static void test_delta_small_edit() {
  new_data[101] = 'Y';
  new_data[102] = 'Z';

-  DeltaSignature* sig = delta_signature_create(old_data, 4096, 1024);
+  DeltaSignature *sig = delta_signature_create(old_data, 4096, 1024);
  EXPECT_NOT_NULL(sig);

-  Delta* delta = delta_compute(new_data, 4096, sig, 1024);
+  Delta *delta = delta_compute(new_data, 4096, sig, 1024);
  EXPECT_NOT_NULL(delta);

  uint64_t total_literal = 0;
@@ -124,7 +122,7 @@ static void test_delta_small_edit() {
  EXPECT_TRUE(match_count > 0);
  EXPECT_TRUE(total_literal < 4096);

-  void* reconstructed = delta_apply(old_data, 4096, delta, 1024);
+  void *reconstructed = delta_apply(old_data, 4096, delta, 1024);
  EXPECT_NOT_NULL(reconstructed);
  EXPECT_EQ_INT(memcmp(reconstructed, new_data, 4096), 0);

@@ -141,10 +139,10 @@ static void test_delta_completely_different() {
    new_data[i] = (char)(i * 13 + 97);
  }

-  DeltaSignature* sig = delta_signature_create(old_data, 4096, 1024);
+  DeltaSignature *sig = delta_signature_create(old_data, 4096, 1024);
  EXPECT_NOT_NULL(sig);

-  Delta* delta = delta_compute(new_data, 4096, sig, 1024);
+  Delta *delta = delta_compute(new_data, 4096, sig, 1024);
  EXPECT_NOT_NULL(delta);

  bool has_match = false;
@@ -171,19 +169,19 @@ static void test_delta_serialize_roundtrip() {
  new_data[500] = 'A';
  new_data[501] = 'B';

-  DeltaSignature* sig = delta_signature_create(old_data, 4096, 1024);
-  Delta* delta = delta_compute(new_data, 4096, sig, 1024);
+  DeltaSignature *sig = delta_signature_create(old_data, 4096, 1024);
+  Delta *delta = delta_compute(new_data, 4096, sig, 1024);
  EXPECT_NOT_NULL(delta);

-  Data* serialized = delta_serialize(delta);
+  Data *serialized = delta_serialize(delta);
  EXPECT_NOT_NULL(serialized);

-  Delta* deserialized = delta_deserialize(serialized);
+  Delta *deserialized = delta_deserialize(serialized);
  EXPECT_NOT_NULL(deserialized);
  EXPECT_EQ_INT((int)deserialized->new_file_size, (int)delta->new_file_size);
  EXPECT_EQ_INT((int)deserialized->instruction_count, (int)delta->instruction_count);

-  void* reconstructed = delta_apply(old_data, 4096, deserialized, 1024);
+  void *reconstructed = delta_apply(old_data, 4096, deserialized, 1024);
  EXPECT_NOT_NULL(reconstructed);
  EXPECT_EQ_INT(memcmp(reconstructed, new_data, 4096), 0);

@@ -197,19 +195,17 @@ static void test_delta_serialize_roundtrip() {
 static void test_delta_file_growth() {
  char old_data[2048];
  char new_data[3072];
-  for (int i = 0; i < 2048; i++)
-    old_data[i] = (char)(i % 256);
+  for (int i = 0; i < 2048; i++) old_data[i] = (char)(i % 256);
  memcpy(new_data, old_data, 2048);
-  for (int i = 2048; i < 3072; i++)
-    new_data[i] = (char)(i % 256);
+  for (int i = 2048; i < 3072; i++) new_data[i] = (char)(i % 256);

-  DeltaSignature* sig = delta_signature_create(old_data, 2048, 512);
+  DeltaSignature *sig = delta_signature_create(old_data, 2048, 512);
  EXPECT_NOT_NULL(sig);

-  Delta* delta = delta_compute(new_data, 3072, sig, 512);
+  Delta *delta = delta_compute(new_data, 3072, sig, 512);
  EXPECT_NOT_NULL(delta);

-  void* reconstructed = delta_apply(old_data, 2048, delta, 512);
+  void *reconstructed = delta_apply(old_data, 2048, delta, 512);
  EXPECT_NOT_NULL(reconstructed);
  EXPECT_EQ_INT(delta->new_file_size, 3072);
  EXPECT_EQ_INT(memcmp(reconstructed, new_data, 3072), 0);
@@ -222,18 +218,16 @@ static void test_delta_file_growth() {
 static void test_delta_file_shrink() {
  char old_data[3072];
  char new_data[2048];
-  for (int i = 0; i < 3072; i++)
-    old_data[i] = (char)(i % 256);
-  for (int i = 0; i < 2048; i++)
-    new_data[i] = old_data[i];
+  for (int i = 0; i < 3072; i++) old_data[i] = (char)(i % 256);
+  for (int i = 0; i < 2048; i++) new_data[i] = old_data[i];

-  DeltaSignature* sig = delta_signature_create(old_data, 3072, 512);
+  DeltaSignature *sig = delta_signature_create(old_data, 3072, 512);
  EXPECT_NOT_NULL(sig);

-  Delta* delta = delta_compute(new_data, 2048, sig, 512);
+  Delta *delta = delta_compute(new_data, 2048, sig, 512);
  EXPECT_NOT_NULL(delta);

-  void* reconstructed = delta_apply(old_data, 3072, delta, 512);
+  void *reconstructed = delta_apply(old_data, 3072, delta, 512);
  EXPECT_NOT_NULL(reconstructed);
  EXPECT_EQ_INT(delta->new_file_size, 2048);
  EXPECT_EQ_INT(memcmp(reconstructed, new_data, 2048), 0);
@@ -279,24 +273,24 @@ static void test_large_file_delta() {
  uint64_t old_size = 200000;
  uint64_t new_size = 200000;

-  void* old_data = malloc((size_t)old_size);
-  void* new_data = malloc((size_t)new_size);
+  void *old_data = malloc((size_t)old_size);
+  void *new_data = malloc((size_t)new_size);
  EXPECT_TRUE(old_data != NULL && new_data != NULL);

  for (uint64_t i = 0; i < old_size; i++)
-    ((uint8_t*)old_data)[i] = (uint8_t)(i % 251);
+    ((uint8_t *)old_data)[i] = (uint8_t)(i % 251);
  memcpy(new_data, old_data, (size_t)old_size);

  uint64_t offset = 100000;
  uint32_t change_len = 4096;
  for (uint32_t i = 0; i < change_len; i++)
-    ((uint8_t*)new_data)[offset + i] = (uint8_t)((i * 7 + 13) % 256);
+    ((uint8_t *)new_data)[offset + i] = (uint8_t)((i * 7 + 13) % 256);

-  DeltaSignature* sig = delta_signature_create(old_data, old_size, block_size);
+  DeltaSignature *sig = delta_signature_create(old_data, old_size, block_size);
  EXPECT_TRUE(sig != NULL);
  EXPECT_TRUE(sig->block_count == (uint32_t)((old_size + block_size - 1) / block_size));

-  Delta* delta = delta_compute(new_data, new_size, sig, block_size);
+  Delta *delta = delta_compute(new_data, new_size, sig, block_size);
  EXPECT_TRUE(delta != NULL);

  uint64_t total_literal = 0;
@@ -307,11 +301,10 @@ static void test_large_file_delta() {
    else
      match_count++;
  }
-  EXPECT_TRUE(total_literal > 0);
  EXPECT_TRUE(match_count > 0);
  EXPECT_TRUE(delta->delta_size < new_size / 2);

-  void* result = delta_apply(old_data, old_size, delta, block_size);
+  void *result = delta_apply(old_data, old_size, delta, block_size);
  EXPECT_TRUE(result != NULL);
  EXPECT_TRUE(delta->new_file_size == new_size);
  EXPECT_TRUE(memcmp(result, new_data, (size_t)new_size) == 0);
@@ -7,12 +7,12 @@
 #include <stdio.h>

 static void test_queue_basic() {
-  Queue* q = queue_create(10, NULL);
+  Queue *q = queue_create(10, NULL);
  EXPECT_NOT_NULL(q);
  EXPECT_TRUE(queue_is_empty(q));
  EXPECT_FALSE(queue_is_full(q));

-  int* vals[5];
+  int *vals[5];
  for (int i = 0; i < 5; i++) {
    vals[i] = malloc(sizeof(int));
    *vals[i] = (i + 1) * 10;
@@ -23,19 +23,19 @@ static void test_queue_basic() {
  EXPECT_FALSE(queue_is_full(q));
  EXPECT_EQ_INT(q->size, 5);

-  int* v1 = (int*)queue_dequeue(q);
+  int *v1 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v1);
  EXPECT_EQ_INT(*v1, 10);
  free(v1);

-  int* v2 = (int*)queue_dequeue(q);
+  int *v2 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v2);
  EXPECT_EQ_INT(*v2, 20);
  free(v2);

  EXPECT_EQ_INT(q->size, 3);

-  int* vals2[3];
+  int *vals2[3];
  for (int i = 0; i < 3; i++) {
    vals2[i] = malloc(sizeof(int));
    *vals2[i] = (i + 6) * 10;
@@ -44,9 +44,9 @@ static void test_queue_basic() {

  EXPECT_EQ_INT(q->size, 6);

-  const int expected_vals[] = {30, 40, 50, 60, 70, 80};
+  int expected_vals[] = {30, 40, 50, 60, 70, 80};
  for (int i = 0; i < 6; i++) {
-    int* v = (int*)queue_dequeue(q);
+    int *v = (int *)queue_dequeue(q);
    EXPECT_NOT_NULL(v);
    EXPECT_EQ_INT(*v, expected_vals[i]);
    free(v);
@@ -57,7 +57,7 @@ static void test_queue_basic() {
 }

 static void test_queue_resize() {
-  Queue* q = queue_create(3, NULL);
+  Queue *q = queue_create(3, NULL);
  EXPECT_NOT_NULL(q);
  EXPECT_EQ_INT(q->capacity, 3);

@@ -69,7 +69,7 @@ static void test_queue_resize() {

  EXPECT_TRUE(queue_is_full(q));

-  const int* v1 = (const int*)queue_dequeue(q);
+  int *v1 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v1);
  EXPECT_EQ_INT(*v1, 1);

@@ -84,19 +84,19 @@ static void test_queue_resize() {
  EXPECT_EQ_INT(q->size, 4);

  // Dequeue all and check order: B, C, D, E
-  const int* v2 = (const int*)queue_dequeue(q);
+  int *v2 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v2);
  EXPECT_EQ_INT(*v2, 2);

-  const int* v3 = (const int*)queue_dequeue(q);
+  int *v3 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v3);
  EXPECT_EQ_INT(*v3, 3);

-  const int* v4 = (const int*)queue_dequeue(q);
+  int *v4 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v4);
  EXPECT_EQ_INT(*v4, 4);

-  const int* v5 = (const int*)queue_dequeue(q);
+  int *v5 = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v5);
  EXPECT_EQ_INT(*v5, 5);

@@ -105,23 +105,23 @@ static void test_queue_resize() {
 }

 static int destroyer_calls = 0;
-static void my_destroyer(void* item) {
+static void my_destroyer(void *item) {
  destroyer_calls++;
  free(item);
 }

 static void test_queue_destroyer() {
  destroyer_calls = 0;
-  Queue* q = queue_create(5, my_destroyer);
+  Queue *q = queue_create(5, my_destroyer);
  EXPECT_NOT_NULL(q);

  for (int i = 0; i < 3; i++) {
-    int* val = malloc(sizeof(int));
+    int *val = malloc(sizeof(int));
    *val = i;
    queue_enqueue(q, val);
  }

-  int* v = (int*)queue_dequeue(q);
+  int *v = (int *)queue_dequeue(q);
  EXPECT_NOT_NULL(v);
  EXPECT_EQ_INT(*v, 0);
  free(v);
@@ -131,19 +131,18 @@ static void test_queue_destroyer() {
 }

 typedef struct {
-  Queue* q;
-  mtx_t* mutex;
-  cnd_t* cnd_empty;
-  cnd_t* cnd_full;
+  Queue *q;
+  mtx_t *mutex;
+  cnd_t *cnd_empty;
+  cnd_t *cnd_full;
  bool done;
  int sum;
 } ThreadContext;

-static int consumer_func(void* arg) {
-  ThreadContext* ctx = (ThreadContext*)arg;
+static int consumer_func(void *arg) {
+  ThreadContext *ctx = (ThreadContext *)arg;
  while (true) {
-    int* val = (int*)queue_dequeue_multithreaded(ctx->q, ctx->mutex, ctx->cnd_empty, ctx->cnd_full,
-                                                 &ctx->done);
+    int *val = (int *)queue_dequeue_multithreaded(ctx->q, ctx->mutex, ctx->cnd_empty, ctx->cnd_full, &ctx->done);
    if (val == NULL) {
      break;
    }
@@ -154,7 +153,7 @@ static int consumer_func(void* arg) {
 }

 static void test_queue_multithreaded() {
-  Queue* q = queue_create(2, NULL);
+  Queue *q = queue_create(2, NULL);
  mtx_t mutex;
  cnd_t cnd_empty;
  cnd_t cnd_full;
@@ -163,19 +162,21 @@ static void test_queue_multithreaded() {
  cnd_init(&cnd_empty);
  cnd_init(&cnd_full);

-  ThreadContext ctx = {.q = q,
-                       .mutex = &mutex,
-                       .cnd_empty = &cnd_empty,
-                       .cnd_full = &cnd_full,
-                       .done = false,
-                       .sum = 0};
+  ThreadContext ctx = {
+    .q = q,
+    .mutex = &mutex,
+    .cnd_empty = &cnd_empty,
+    .cnd_full = &cnd_full,
+    .done = false,
+    .sum = 0
+  };

  thrd_t consumer;
  int res = thrd_create(&consumer, consumer_func, &ctx);
  EXPECT_EQ_INT(res, thrd_success);

  for (int i = 1; i <= 100; i++) {
-    int* val = malloc(sizeof(int));
+    int *val = malloc(sizeof(int));
    *val = i;
    queue_enqueue_multithreaded(q, val, &mutex, &cnd_empty, &cnd_full);
  }
@@ -6,28 +6,27 @@
 #include <sys/stat.h>
 #include <unistd.h>

-static void create_test_file(const char* path, const char* content) {
+static void create_test_file(const char *path, const char *content) {
  (void)to_disk(path, content, strlen(content));
 }

 static void test_scanner_single_file() {
-  const char* dir = "test_scan_dir_single";
-  const char* file1 = "test_scan_dir_single/file1.txt";
-  const char* content1 = "hello scanner";
+  const char *dir = "test_scan_dir_single";
+  const char *file1 = "test_scan_dir_single/file1.txt";
+  const char *content1 = "hello scanner";

  mkdir(dir, 0755);
  create_test_file(file1, content1);

-  DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
+  DirectoryScanner *scanner = directory_scanner_create((char *)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
  EXPECT_NOT_NULL(scanner);

-  Chunk* chunk = directory_scanner_next(scanner);
+  Chunk *chunk = directory_scanner_next(scanner);
  EXPECT_NOT_NULL(chunk);
  EXPECT_EQ_INT(chunk->element_count, 1);
  EXPECT_EQ_STR(chunk->items[0]->path, file1);

-  const Chunk* next = directory_scanner_next(scanner);
+  Chunk *next = directory_scanner_next(scanner);
  EXPECT_NULL(next);

  chunk_destroy(chunk);
@@ -37,38 +36,35 @@ static void test_scanner_single_file() {
 }

 static void test_scanner_multiple_files() {
-  const char* dir = "test_scan_dir_multi";
-  const char* file1 = "test_scan_dir_multi/a.txt";
-  const char* file2 = "test_scan_dir_multi/b.txt";
-  const char* content1 = "alpha";
-  const char* content2 = "beta";
+  const char *dir = "test_scan_dir_multi";
+  const char *file1 = "test_scan_dir_multi/a.txt";
+  const char *file2 = "test_scan_dir_multi/b.txt";
+  const char *content1 = "alpha";
+  const char *content2 = "beta";

  mkdir(dir, 0755);
  create_test_file(file1, content1);
  create_test_file(file2, content2);

-  DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
+  DirectoryScanner *scanner = directory_scanner_create((char *)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
  EXPECT_NOT_NULL(scanner);

-  const Chunk* chunk = directory_scanner_next(scanner);
+  Chunk *chunk = directory_scanner_next(scanner);
  EXPECT_NOT_NULL(chunk);
  EXPECT_EQ_INT(chunk->element_count, 2);

  int found1 = 0, found2 = 0;
  for (int i = 0; i < chunk->element_count; i++) {
-    if (strcmp(chunk->items[i]->path, file1) == 0)
-      found1 = 1;
-    if (strcmp(chunk->items[i]->path, file2) == 0)
-      found2 = 1;
+    if (strcmp(chunk->items[i]->path, file1) == 0) found1 = 1;
+    if (strcmp(chunk->items[i]->path, file2) == 0) found2 = 1;
  }
  EXPECT_TRUE(found1);
  EXPECT_TRUE(found2);

-  const Chunk* next = directory_scanner_next(scanner);
+  Chunk *next = directory_scanner_next(scanner);
  EXPECT_NULL(next);

-  chunk_destroy((void*)chunk);
+  chunk_destroy(chunk);
  directory_scanner_destroy(scanner);
  unlink(file1);
  unlink(file2);
@@ -76,23 +72,22 @@ static void test_scanner_multiple_files() {
 }

 static void test_scanner_subdirectory() {
-  const char* root = "test_scan_sub";
-  const char* sub = "test_scan_sub/sub";
-  const char* root_file = "test_scan_sub/root.txt";
-  const char* sub_file = "test_scan_sub/sub/sub_file.txt";
-  const char* content = "nested content";
+  const char *root = "test_scan_sub";
+  const char *sub = "test_scan_sub/sub";
+  const char *root_file = "test_scan_sub/root.txt";
+  const char *sub_file = "test_scan_sub/sub/sub_file.txt";
+  const char *content = "nested content";

  mkdir(root, 0755);
  mkdir(sub, 0755);
  create_test_file(root_file, content);
  create_test_file(sub_file, content);

-  DirectoryScanner* scanner =
-      directory_scanner_create((char*)root, false, 0, NULL, 0, NULL, 0, 0, 0);
+  DirectoryScanner *scanner = directory_scanner_create((char *)root, false, 0, NULL, 0, NULL, 0, 0, 0);
  EXPECT_NOT_NULL(scanner);

  int total_files = 0;
-  Chunk* chunk;
+  Chunk *chunk;
  while ((chunk = directory_scanner_next(scanner)) != NULL) {
    total_files += chunk->element_count;
    chunk_destroy(chunk);
@@ -107,15 +102,14 @@ static void test_scanner_subdirectory() {
 }

 static void test_scanner_empty_directory() {
-  const char* dir = "test_scan_empty";
+  const char *dir = "test_scan_empty";

  mkdir(dir, 0755);

-  DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
+  DirectoryScanner *scanner = directory_scanner_create((char *)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
  EXPECT_NOT_NULL(scanner);

-  const Chunk* chunk = directory_scanner_next(scanner);
+  Chunk *chunk = directory_scanner_next(scanner);
  EXPECT_NULL(chunk);

  directory_scanner_destroy(scanner);
@@ -6,56 +6,56 @@

 void test_shared_utils() {
  // Test str_dup
-  const char* dup_null = str_dup(NULL);
+  char *dup_null = str_dup(NULL);
  EXPECT_NULL(dup_null);
  
-  char* dup_empty = str_dup("");
+  char *dup_empty = str_dup("");
  EXPECT_NOT_NULL(dup_empty);
  EXPECT_EQ_STR(dup_empty, "");
  free(dup_empty);
  
-  char* dup_normal = str_dup("hello world");
+  char *dup_normal = str_dup("hello world");
  EXPECT_NOT_NULL(dup_normal);
  EXPECT_EQ_STR(dup_normal, "hello world");
  free(dup_normal);
  
  // Test path_cat
-  char* cat1 = path_cat("/foo", "/bar");
+  char *cat1 = path_cat("/foo", "/bar");
  EXPECT_NOT_NULL(cat1);
  EXPECT_EQ_STR(cat1, "/foo/bar");
  free(cat1);
  
-  char* cat2 = path_cat("/foo/", "/bar");
+  char *cat2 = path_cat("/foo/", "/bar");
  EXPECT_NOT_NULL(cat2);
  EXPECT_EQ_STR(cat2, "/foo/bar");
  free(cat2);
  
-  char* cat3 = path_cat("/foo", "bar");
+  char *cat3 = path_cat("/foo", "bar");
  EXPECT_NOT_NULL(cat3);
  EXPECT_EQ_STR(cat3, "/foo/bar");
  free(cat3);
  
-  char* cat4 = path_cat("/foo/", "bar");
+  char *cat4 = path_cat("/foo/", "bar");
  EXPECT_NOT_NULL(cat4);
  EXPECT_EQ_STR(cat4, "/foo/bar");
  free(cat4);
  
-  char* cat_empty1 = path_cat("", "/bar");
+  char *cat_empty1 = path_cat("", "/bar");
  EXPECT_NOT_NULL(cat_empty1);
  EXPECT_EQ_STR(cat_empty1, "/bar");
  free(cat_empty1);
  
-  char* cat_empty2 = path_cat("/foo", "");
+  char *cat_empty2 = path_cat("/foo", "");
  EXPECT_NOT_NULL(cat_empty2);
  EXPECT_EQ_STR(cat_empty2, "/foo");
  free(cat_empty2);
  
-  char* cat_null1 = path_cat(NULL, "/bar");
+  char *cat_null1 = path_cat(NULL, "/bar");
  EXPECT_NOT_NULL(cat_null1);
  EXPECT_EQ_STR(cat_null1, "/bar");
  free(cat_null1);
  
-  char* cat_null2 = path_cat("/foo", NULL);
+  char *cat_null2 = path_cat("/foo", NULL);
  EXPECT_NOT_NULL(cat_null2);
  EXPECT_EQ_STR(cat_null2, "/foo");
  free(cat_null2);
@@ -11,90 +11,84 @@ extern int tests_failed;
 extern bool current_test_failed;

 // Helper to run a test function
-#define RUN_TEST(test_func)                                                                        \
-  do {                                                                                             \
-    printf("Running %s...\n", #test_func);                                                         \
-    tests_run++;                                                                                   \
-    current_test_failed = false;                                                                   \
-    test_func();                                                                                   \
-    if (current_test_failed) {                                                                     \
-      tests_failed++;                                                                              \
-      printf("  \033[1;31m[FAILED]\033[0m %s\n", #test_func);                                      \
-    } else {                                                                                       \
-      printf("  \033[1;32m[PASSED]\033[0m %s\n", #test_func);                                      \
-    }                                                                                              \
+#define RUN_TEST(test_func) \
+  do { \
+    printf("Running %s...\n", #test_func); \
+    tests_run++; \
+    current_test_failed = false; \
+    test_func(); \
+    if (current_test_failed) { \
+      tests_failed++; \
+      printf("  \033[1;31m[FAILED]\033[0m %s\n", #test_func); \
+    } else { \
+      printf("  \033[1;32m[PASSED]\033[0m %s\n", #test_func); \
+    } \
  } while (0)

 // Assertion macros
-#define EXPECT_TRUE(condition)                                                                     \
-  do {                                                                                             \
-    if (!(condition)) {                                                                            \
-      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is false\n", __FILE__,       \
-             __LINE__, #condition);                                                                \
-      current_test_failed = true;                                                                  \
-      return;                                                                                      \
-    }                                                                                              \
+#define EXPECT_TRUE(condition) \
+  do { \
+    if (!(condition)) { \
+      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is false\n", __FILE__, __LINE__, #condition); \
+      current_test_failed = true; \
+      return; \
+    } \
  } while (0)

-#define EXPECT_FALSE(condition)                                                                    \
-  do {                                                                                             \
-    if (condition) {                                                                               \
-      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is true\n", __FILE__,        \
-             __LINE__, #condition);                                                                \
-      current_test_failed = true;                                                                  \
-      return;                                                                                      \
-    }                                                                                              \
+#define EXPECT_FALSE(condition) \
+  do { \
+    if (condition) { \
+      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is true\n", __FILE__, __LINE__, #condition); \
+      current_test_failed = true; \
+      return; \
+    } \
  } while (0)

-#define EXPECT_EQ_INT(actual, expected)                                                            \
-  do {                                                                                             \
-    int act = (actual);                                                                            \
-    int exp = (expected);                                                                          \
-    if (act != exp) {                                                                              \
-      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected %d, got %d\n", __FILE__, __LINE__, exp,  \
-             act);                                                                                 \
-      current_test_failed = true;                                                                  \
-      return;                                                                                      \
-    }                                                                                              \
+#define EXPECT_EQ_INT(actual, expected) \
+  do { \
+    int act = (actual); \
+    int exp = (expected); \
+    if (act != exp) { \
+      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected %d, got %d\n", __FILE__, __LINE__, exp, act); \
+      current_test_failed = true; \
+      return; \
+    } \
  } while (0)

-#define EXPECT_EQ_STR(actual, expected)                                                            \
-  do {                                                                                             \
-    const char* act = (actual);                                                                    \
-    const char* exp = (expected);                                                                  \
-    if (act == NULL || exp == NULL) {                                                              \
-      if (act != exp) {                                                                            \
-        printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected %s, got %s\n", __FILE__, __LINE__,     \
-               exp ? exp : "NULL", act ? act : "NULL");                                            \
-        current_test_failed = true;                                                                \
-        return;                                                                                    \
-      }                                                                                            \
-    } else if (strcmp(act, exp) != 0) {                                                            \
-      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected \"%s\", got \"%s\"\n", __FILE__,         \
-             __LINE__, exp, act);                                                                  \
-      current_test_failed = true;                                                                  \
-      return;                                                                                      \
-    }                                                                                              \
+#define EXPECT_EQ_STR(actual, expected) \
+  do { \
+    const char *act = (actual); \
+    const char *exp = (expected); \
+    if (act == NULL || exp == NULL) { \
+      if (act != exp) { \
+        printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected %s, got %s\n", __FILE__, __LINE__, \
+               exp ? exp : "NULL", act ? act : "NULL"); \
+        current_test_failed = true; \
+        return; \
+      } \
+    } else if (strcmp(act, exp) != 0) { \
+      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected \"%s\", got \"%s\"\n", __FILE__, __LINE__, exp, act); \
+      current_test_failed = true; \
+      return; \
+    } \
  } while (0)

-#define EXPECT_NOT_NULL(ptr)                                                                       \
-  do {                                                                                             \
-    if ((ptr) == NULL) {                                                                           \
-      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected non-null pointer, got NULL\n", __FILE__, \
-             __LINE__);                                                                            \
-      current_test_failed = true;                                                                  \
-      return;                                                                                      \
-    }                                                                                              \
+#define EXPECT_NOT_NULL(ptr) \
+  do { \
+    if ((ptr) == NULL) { \
+      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected non-null pointer, got NULL\n", __FILE__, __LINE__); \
+      current_test_failed = true; \
+      return; \
+    } \
  } while (0)

-#define EXPECT_NULL(ptr)                                                                           \
-  do {                                                                                             \
-    if ((ptr) != NULL) {                                                                           \
-      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected NULL, got %p\n", __FILE__, __LINE__,     \
-             (void*)(ptr));                                                                        \
-      current_test_failed = true;                                                                  \
-      return;                                                                                      \
-    }                                                                                              \
+#define EXPECT_NULL(ptr) \
+  do { \
+    if ((ptr) != NULL) { \
+      printf("    \033[1;31m[FAIL]\033[0m %s:%d: Expected NULL, got %p\n", __FILE__, __LINE__, (void*)(ptr)); \
+      current_test_failed = true; \
+      return; \
+    } \
  } while (0)

 #endif