src/client/client_cli.c

@@ -70,10 +70,14 @@ int main(int argc, char* argv[]) {
     save_to_disk = true;
   }
 
-  Config* config = config_create(str_dup(PROTOCOL_VERSION), NULL, NULL, save_to_disk, false, false,
-                                 false, false, 5, false, 0);
   int exit_code = 0;
   bool config_owned_by_pipeline = false;
+  Config* config = config_create(str_dup(PROTOCOL_VERSION), NULL, NULL, save_to_disk, false, false,
+                                 false, false, 5, false, 0);
+  if (config == NULL) {
+    exit_code = 1;
+    goto cleanup;
+  }
 
   int positional_args[2];
   int positional_count = 0;

src/client/scanner.c

@@ -91,7 +91,19 @@ DirectoryScanner* directory_scanner_create_full(char* root_directory, bool use_m
   scanner->max_size = max_size;
   scanner->min_size = min_size;
   scanner->follow_symlinks = follow_symlinks;
-  queue_enqueue(scanner->directories, str_dup(root_directory));
+  char* root_copy = str_dup(root_directory);
+  if (root_copy == NULL) {
+    for (int i = 0; i < scanner->include_count; i++)
+      free(scanner->include_patterns[i]);
+    free(scanner->include_patterns);
+    for (int i = 0; i < scanner->exclude_count; i++)
+      free(scanner->exclude_patterns[i]);
+    free(scanner->exclude_patterns);
+    queue_destroy(scanner->directories);
+    free(scanner);
+    return NULL;
+  }
+  queue_enqueue(scanner->directories, root_copy);
   return scanner;
 }
 

src/server/server.c

@@ -247,10 +247,9 @@ int main(int argc, char* argv[]) {
     server_listen(g_server, handler);
   }
 
-  /* Graceful shutdown: if a signal requested cleanup, delete the server */
-  if (g_server_cleanup_requested) {
+  /* Graceful shutdown: delete the server */
+  if (g_server_cleanup_requested)
     log_message(LOG_LEVEL_INFO, "Shutdown requested, cleaning up");
-    server_delete(&g_server);
-  }
+  server_delete(&g_server);
   return 0;
 }

src/shared/config.c

@@ -82,6 +82,8 @@ void config_parse_ssh_dest(Config* config) {
 }
 
 void config_delete(Config* config) {
+  if (config == NULL)
+    return;
   free(config->version);
   free(config->send_directory);
   free(config->receive_root_directory);
@@ -260,10 +262,6 @@ Config* config_receive(int file_descriptor) {
                 MAX_PATTERN_COUNT);
     goto error;
   }
-  if ((size_t)ec > SIZE_MAX / sizeof(char*)) {
-    log_message(LOG_LEVEL_ERROR, "Exclude pattern count %d would cause integer overflow", ec);
-    goto error;
-  }
   config->exclude_count = ec;
   if (ec > 0) {
     config->exclude_patterns = malloc((size_t)ec * sizeof(char*));
@@ -293,10 +291,6 @@ Config* config_receive(int file_descriptor) {
                 MAX_PATTERN_COUNT);
     goto error;
   }
-  if ((size_t)ic > SIZE_MAX / sizeof(char*)) {
-    log_message(LOG_LEVEL_ERROR, "Include pattern count %d would cause integer overflow", ic);
-    goto error;
-  }
   config->include_count = ic;
   if (ic > 0) {
     config->include_patterns = malloc((size_t)ic * sizeof(char*));
@@ -340,6 +334,16 @@ error:
   free(config->version);
   free(config->send_directory);
   free(config->receive_root_directory);
+  for (int i = 0; i < config->exclude_count; i++)
+    free(config->exclude_patterns[i]);
+  free(config->exclude_patterns);
+  for (int i = 0; i < config->include_count; i++)
+    free(config->include_patterns[i]);
+  free(config->include_patterns);
+  free(config->tls_cert);
+  free(config->tls_key);
+  free(config->tls_ca);
+  free(config->ssh_destination);
   free(config->server_host);
   free(config);
   return NULL;

src/shared/config.h

@@ -44,7 +44,7 @@ typedef struct Config {
   bool partial;
 } Config;
 
-#define PROTOCOL_VERSION "1.3.0"
+#define PROTOCOL_VERSION "2.0.0"
 #define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)
 
 Config* config_create(char* version, char* send_directory, char* receive_directory,

src/shared/data.c

@@ -1,6 +1,6 @@
 #include "data.h"
 #include "log.h"
-#include "stdlib.h"
+#include <stdlib.h>
 
 Data* data_create_empty(size_t data_size) {
   /* malloc(0) is UB; allocate at least 1 byte but preserve requested size */

src/shared/file.c

@@ -1,7 +1,9 @@
 #include <dirent.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <libgen.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -108,6 +110,9 @@ bool file_load_data(File* file) {
   size_t bytes_read = file_content_to_buffer(file);
   if (bytes_read != file->data->size) {
     log_message(LOG_LEVEL_ERROR, "Did not read expected amount of bytes from file");
+    free(file->data->data);
+    file->data->data = NULL;
+    file->data->size = 0;
     return false;
   }
   return true;
@@ -139,11 +144,13 @@ static bool file_send_streaming(File* file, int file_descriptor) {
       if (ferror(fp)) {
         perror("Read error during streaming");
       }
+      send_status(file_descriptor, STATUS_ERROR);
       free(buf);
       fclose(fp);
       return false;
     }
     if (!send_n_data(file_descriptor, buf, nread)) {
+      send_status(file_descriptor, STATUS_ERROR);
       free(buf);
       fclose(fp);
       return false;
@@ -295,17 +302,21 @@ static bool receive_and_assign_metadata(int fd, const Config* config, File* file
 
 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)
+  if (!old_data) {
+    send_status(fd, STATUS_ERROR);
     return NULL;
+  }
 
   DeltaSignature* sig = delta_signature_create(old_data, old_size, config->delta_block_size);
   if (!sig) {
+    send_status(fd, STATUS_ERROR);
     free(old_data);
     return NULL;
   }
 
   Data* sig_data = delta_signature_serialize(sig);
   if (!sig_data) {
+    send_status(fd, STATUS_ERROR);
     delta_signature_destroy(sig);
     free(old_data);
     return NULL;
@@ -517,7 +528,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   if (!receive_and_assign_metadata(fd, config, file))
     return NULL;
 
-  // Read file type indicator
   int file_type;
   if (!receive_int(fd, &file_type)) {
     file_destroy(file);
@@ -604,7 +614,6 @@ bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int
   if (use_metadata && !metadata_send(file_descriptor, file->metadata))
     return false;
 
-  // Send file type indicator
   int ft = (int)file->type;
   if (!send_int(file_descriptor, ft))
     return false;
@@ -623,8 +632,13 @@ bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int
 
   off_t offset = 0;
   while ((unsigned long long)offset < file_size) {
-    ssize_t sent = sendfile(file_descriptor, fd, &offset, file_size - offset);
+    size_t send_count = (size_t)(file_size - (unsigned long long)offset);
+    if ((unsigned long long)send_count != file_size - (unsigned long long)offset)
+      send_count = SIZE_MAX;
+    ssize_t sent = sendfile(file_descriptor, fd, &offset, send_count);
     if (sent == -1) {
+      if (errno == EINTR)
+        continue;
       perror("sendfile failed");
       close(fd);
       return false;

src/shared/log.c

@@ -16,6 +16,8 @@ void log_message(LogLevel log_level, const char* format, ...) {
   time_t now = time(NULL);
   struct tm result_buf;
   const struct tm* t = localtime_r(&now, &result_buf);
+  if (t == NULL)
+    return;
 
   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]);

src/shared/metadata.c

@@ -11,6 +11,19 @@
 #include <time.h>
 #include <unistd.h>
 
+/*
+ * Wire format serialization (protocol version 2.0.0+):
+ * All metadata fields are serialized as fixed-width integers (int32_t / int64_t)
+ * to ensure cross-platform binary compatiblity.  See metadata.h for the
+ * exact wire layout.
+ *
+ * Compile-time assertions verify that the native platform types fit within
+ * the chosen fixed-width representations.
+ */
+typedef char static_assert_mode_t_fits[(sizeof(mode_t) <= sizeof(int32_t)) ? 1 : -1];
+typedef char static_assert_uid_t_fits[(sizeof(uid_t) <= sizeof(int32_t)) ? 1 : -1];
+typedef char static_assert_gid_t_fits[(sizeof(gid_t) <= sizeof(int32_t)) ? 1 : -1];
+
 void metadata_to_buf(char** buf, const FileMetadata* m) {
   int32_t present = (m != NULL) ? 1 : 0;
   memcpy(*buf, &present, sizeof(present));

src/shared/metadata.h

@@ -6,6 +6,23 @@
 #include <stdint.h>
 #include <sys/stat.h>
 
+/*
+ * Wire format (introduced in protocol version 2.0.0):
+ *   int32_t present
+ *   int32_t mode    (was mode_t, platform-dependent)
+ *   int32_t uid     (was uid_t,  platform-dependent)
+ *   int32_t gid     (was gid_t,  platform-dependent)
+ *   int64_t mtime_sec (was time_t, platform-dependent)
+ *   int64_t mtime_nsec (was long,  platform-dependent)
+ *
+ * Prior to 2.0.0 the wire format used the raw platform-dependent types,
+ * which broke compatiblity across different systems.  All fields are now
+ * serialized as fixed-width integers.
+ */
+
+/* Size of metadata fields on wire, excluding the int32_t `present` field that
+ * is always sent first. The total wire size for present metadata is
+ * sizeof(int32_t) + FILE_METADATA_WIRE_SIZE (32 bytes on most platforms). */
 #define FILE_METADATA_WIRE_SIZE (sizeof(int32_t) * 3 + sizeof(int64_t) * 2)
 
 void metadata_to_buf(char** buf, const FileMetadata* m);

src/shared/protocol.c

@@ -34,14 +34,11 @@ static void bw_throttle(size_t bytes_written) {
   struct timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
 
-  /* Use unsigned long long for elapsed_ns to avoid overflow in multiplication.
-   * time_t differences fit comfortably in 64-bit for any practical runtime. */
-  unsigned long long elapsed_ns =
-      (unsigned long long)(now.tv_sec - bw_last_refill.tv_sec) * 1000000000ULL +
-      (unsigned long long)(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 * (double)elapsed_ns / 1000000000.0);
+  long long tokens_to_add = (long long)((double)io_bwlimit * elapsed_ns / 1000000000.0);
   bw_tokens += tokens_to_add;
   if (bw_tokens > (long long)io_bwlimit)
     bw_tokens = (long long)io_bwlimit;
@@ -49,9 +46,7 @@ static void bw_throttle(size_t bytes_written) {
   bw_tokens -= (long long)bytes_written;
 
   if (bw_tokens < 0) {
-    long long deficit_ns = (long long)((double)(-bw_tokens) / (double)io_bwlimit * 1000000000.0);
-    if (deficit_ns < 0)
-      deficit_ns = 0;
+    long long deficit_ns = (long long)((double)(-bw_tokens) / io_bwlimit * 1000000000.0);
     struct timespec sleep_time, remaining;
     sleep_time.tv_sec = deficit_ns / 1000000000LL;
     sleep_time.tv_nsec = deficit_ns % 1000000000LL;
@@ -112,7 +107,7 @@ bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
       bytes_received =
           read(fd, (char*)data + total_bytes_received, data_size - total_bytes_received);
     if (bytes_received <= 0) {
-      if (io_ssl) {
+      if (io_ssl && bytes_received < 0) {
         int ssl_err = SSL_get_error(io_ssl, (int)bytes_received);
         if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE)
           continue;
@@ -193,18 +188,18 @@ bool send_data(int file_descriptor, const Data* data) {
     return false;
   if (!send_n_data(file_descriptor, data->data, data_size))
     return false;
-  log_message(LOG_LEVEL_DEBUG, "Send %lld data", data_size);
+  log_message(LOG_LEVEL_DEBUG, "Send %llu data", data_size);
   return true;
 }
 
-#define MAX_DATA_SIZE (1024ULL * 1024 * 1024) // 1 GB
+#define MAX_DATA_SIZE (1024ULL * 1024 * 1024)
 
 Data* receive_data(int file_descriptor) {
   unsigned long long size = 0;
   if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
     return NULL;
-  if (size > MAX_DATA_SIZE) {
-    log_message(LOG_LEVEL_ERROR, "receive_data: size %llu exceeds maximum", size);
+  if ((size_t)size != size || size > MAX_DATA_SIZE) {
+    log_message(LOG_LEVEL_ERROR, "receive_data size %llu exceeds limits", size);
     return NULL;
   }
   void* data = malloc((size_t)size);
@@ -214,7 +209,7 @@ Data* receive_data(int file_descriptor) {
     free(data);
     return NULL;
   }
-  log_message(LOG_LEVEL_DEBUG, "Received %lld data", size);
+  log_message(LOG_LEVEL_DEBUG, "Received %llu data", size);
   return data_create(data, (size_t)size);
 }
 

src/shared/transport_ssh.c

@@ -119,10 +119,13 @@ Client* client_connect_ssh(const char* destination, int port) {
       close(sv[1]);
 
     char ssh_user[512];
+    int needed;
     if (r.user && r.user[0] != '\0')
-      snprintf(ssh_user, sizeof(ssh_user), "%s@%s", r.user, r.host);
+      needed = snprintf(ssh_user, sizeof(ssh_user), "%s@%s", r.user, r.host);
     else
-      snprintf(ssh_user, sizeof(ssh_user), "%s", r.host);
+      needed = snprintf(ssh_user, sizeof(ssh_user), "%s", r.host);
+    if ((size_t)needed >= sizeof(ssh_user))
+      fprintf(stderr, "Warning: ssh_user string truncated\n");
 
     size_t ssh_argv_max = 32;
     char** ssh_argv = calloc(ssh_argv_max, sizeof(char*));

src/shared/utils.c

@@ -134,7 +134,7 @@ static void delete_extras_walk(const char* abs_path, const char* rel_path, Array
   if (!dir)
     return;
   bool all_removed = true;
-  struct dirent* entry;
+  const struct dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
     if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
       continue;
@@ -184,18 +184,17 @@ 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(const char* path1, const 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;
   if (path1[path1_len - 1] == '/')
     path1_len -= 1;
   if (path2[0] == '/') {
-    path2_pointer += 1;
+    path2++;
     path2_len -= 1;
   }
   char* new_path = malloc(path1_len + path2_len + 2);
@@ -203,7 +202,7 @@ char* path_cat(const char* path1, char* path2) {
     return NULL;
   memcpy(new_path, path1, path1_len);
   new_path[path1_len] = '/';
-  memcpy(new_path + path1_len + 1, path2_pointer, path2_len);
+  memcpy(new_path + path1_len + 1, path2, path2_len);
   new_path[path1_len + path2_len + 1] = '\0';
   return new_path;
 }

src/shared/utils.h

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

tests/test_protocol.c

@@ -46,6 +46,7 @@ static void test_send_receive_str() {
 
   EXPECT_TRUE(send_str(0, ""));
 
+  /* cppcheck-suppress constVariablePointer */
   char* received = receive_str(0);
   EXPECT_NOT_NULL(received);
   EXPECT_EQ_STR(received, "");
@@ -63,6 +64,7 @@ static void test_send_receive_str_normal() {
 
   EXPECT_TRUE(send_str(0, "Hello, Protocol!"));
 
+  /* cppcheck-suppress constVariablePointer */
   char* received = receive_str(0);
   EXPECT_NOT_NULL(received);
   EXPECT_EQ_STR(received, "Hello, Protocol!");
@@ -78,6 +80,7 @@ static void test_send_receive_data() {
   io_set_fds(p[0], p[1]);
   io_set_bwlimit(0);
 
+  /* cppcheck-suppress constVariablePointer */
   unsigned char bin[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0xFF};
   void* buf = malloc(sizeof(bin));
   EXPECT_NOT_NULL(buf);
@@ -128,6 +131,7 @@ static void test_send_receive_status() {
   io_set_fds(p[0], p[1]);
   io_set_bwlimit(0);
 
+  /* cppcheck-suppress constVariablePointer */
   Status statuses[] = {STATUS_OK,    STATUS_ERROR, STATUS_FINISHED,        STATUS_NEXT,
                        STATUS_CHUNK, STATUS_CHECK, STATUS_DELTA_SIGNATURE, STATUS_DELTA_DATA};
   int count = sizeof(statuses) / sizeof(statuses[0]);
@@ -179,8 +183,7 @@ static void test_receive_str_oversized() {
   size_t huge = MAX_STRING_SIZE + 1;
   EXPECT_TRUE(send_n_data(0, &huge, sizeof(size_t)));
 
-  /* cppcheck-suppress constVariablePointer */
-  char* received = receive_str(0);
+  const char* received = receive_str(0);
   EXPECT_NULL(received);
 
   close(p[0]);

tests/test_scanner.c

@@ -15,7 +15,7 @@ static void test_scanner_single_file() {
   const char* file1 = "test_scan_dir_single/file1.txt";
   const char* content1 = "hello scanner";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(file1, content1);
 
   DirectoryScanner* scanner =
@@ -43,7 +43,7 @@ static void test_scanner_multiple_files() {
   const char* content1 = "alpha";
   const char* content2 = "beta";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(file1, content1);
   create_test_file(file2, content2);
 
@@ -82,8 +82,8 @@ static void test_scanner_subdirectory() {
   const char* sub_file = "test_scan_sub/sub/sub_file.txt";
   const char* content = "nested content";
 
-  mkdir(root, 0755);
-  mkdir(sub, 0755);
+  EXPECT_EQ_INT(mkdir(root, 0755), 0);
+  EXPECT_EQ_INT(mkdir(sub, 0755), 0);
   create_test_file(root_file, content);
   create_test_file(sub_file, content);
 
@@ -109,7 +109,7 @@ static void test_scanner_subdirectory() {
 static void test_scanner_empty_directory() {
   const char* dir = "test_scan_empty";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
 
   DirectoryScanner* scanner =
       directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
@@ -130,7 +130,7 @@ static void test_scanner_exclude_pattern() {
   const char* f_tmp = "test_scan_excl/remove.tmp";
   const char* content = "data";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(f_txt, content);
   create_test_file(f_tmp, content);
 
@@ -154,8 +154,6 @@ static void test_scanner_exclude_pattern() {
 }
 
 static void test_scanner_exclude_subdirectory() {
-  /* Exclude patterns match filenames only (via entry->d_name).
-   * Files inside subdirectories are also matched by filename. */
   const char* root = "test_scan_excl_sub";
   const char* sub = "test_scan_excl_sub/sub";
   const char* root_txt = "test_scan_excl_sub/root.txt";
@@ -163,13 +161,12 @@ static void test_scanner_exclude_subdirectory() {
   const char* sub_tmp = "test_scan_excl_sub/sub/temp.tmp";
   const char* content = "data";
 
-  mkdir(root, 0755);
-  mkdir(sub, 0755);
+  EXPECT_EQ_INT(mkdir(root, 0755), 0);
+  EXPECT_EQ_INT(mkdir(sub, 0755), 0);
   create_test_file(root_txt, content);
   create_test_file(sub_txt, content);
   create_test_file(sub_tmp, content);
 
-  /* Exclude *.tmp — should exclude sub/temp.tmp but keep root.txt and sub/data.txt */
   char* exclude[] = {"*.tmp"};
   DirectoryScanner* scanner =
       directory_scanner_create((char*)root, false, 0, exclude, 1, NULL, 0, 0, 0);
@@ -180,7 +177,6 @@ static void test_scanner_exclude_subdirectory() {
   while ((chunk = directory_scanner_next(scanner)) != NULL) {
     total += chunk->element_count;
     for (int i = 0; i < chunk->element_count; i++) {
-      /* No path should end in .tmp */
       size_t len = strlen(chunk->items[i]->path);
       EXPECT_TRUE(len < 4 || strcmp(chunk->items[i]->path + len - 4, ".tmp") != 0);
     }
@@ -197,22 +193,17 @@ static void test_scanner_exclude_subdirectory() {
 }
 
 static void test_scanner_include_and_exclude() {
-  /* In the scanner, exclude is checked first and takes precedence.
-   * Include patterns act as an additional filter: if include_count > 0,
-   * the file must match one of the include patterns (after not being excluded).
-   * This test uses non-overlapping exclude and include patterns. */
   const char* dir = "test_scan_inc_exc";
   const char* f_txt = "test_scan_inc_exc/a.txt";
   const char* f_log = "test_scan_inc_exc/b.log";
   const char* f_bak = "test_scan_inc_exc/c.bak";
   const char* content = "filter";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(f_txt, content);
   create_test_file(f_log, content);
   create_test_file(f_bak, content);
 
-  /* Exclude *.bak. Include *.txt and *.log. */
   char* exclude[] = {"*.bak"};
   char* include[] = {"*.txt", "*.log"};
   DirectoryScanner* scanner =
@@ -230,7 +221,6 @@ static void test_scanner_include_and_exclude() {
     if (strstr(chunk->items[i]->path, "b.log"))
       found_log = 1;
   }
-  /* a.txt included by *.txt, b.log included by *.log, c.bak excluded by *.bak */
   EXPECT_TRUE(found_txt);
   EXPECT_TRUE(found_log);
 
@@ -248,8 +238,7 @@ static void test_scanner_max_size() {
   const char* dir = "test_scan_max";
   const char* small = "test_scan_max/small.txt";
   const char* large = "test_scan_max/large.txt";
-
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(small, "tiny");
   create_test_file(large, "this_content_is_longer_than_ten_chars");
 
@@ -277,7 +266,7 @@ static void test_scanner_min_size() {
   const char* empty_f = "test_scan_min/empty.txt";
   const char* data_f = "test_scan_min/data.txt";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(empty_f, "");
   create_test_file(data_f, "some content here");
 
@@ -306,7 +295,7 @@ static void test_scanner_size_range() {
   const char* medium = "test_scan_range/med.txt";
   const char* huge = "test_scan_range/huge.txt";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(tiny, "ab");
   create_test_file(medium, "hello world");
   create_test_file(huge, "this is a much larger file for testing size filters");
@@ -339,7 +328,7 @@ static void test_scanner_mixed_patterns() {
   const char* c_txt = "test_scan_mixed/c.txt"; /* size ~= 5  */
   const char* d_bak = "test_scan_mixed/d.bak"; /* size ~= 42 */
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(a_txt, "aaaaa");
   create_test_file(b_bin, "bbbbbbbbbbbbb");
   create_test_file(c_txt, "ccccc");
@@ -375,7 +364,7 @@ static void test_scanner_no_patterns() {
   const char* f1 = "test_scan_none/f1.txt";
   const char* f2 = "test_scan_none/f2.txt";
 
-  mkdir(dir, 0755);
+  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
   create_test_file(f1, "first");
   create_test_file(f2, "second");