diff --git a/src/client/client_cli.c b/src/client/client_cli.c index 891afeb..0ebc391 100644 --- a/src/client/client_cli.c +++ b/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; diff --git a/src/client/scanner.c b/src/client/scanner.c index 0f56f68..f4e48ad 100644 --- a/src/client/scanner.c +++ b/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; } diff --git a/src/server/server.c b/src/server/server.c index 9df4e92..141ecdc 100644 --- a/src/server/server.c +++ b/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; } diff --git a/src/shared/config.c b/src/shared/config.c index b9ff23c..e4654b3 100644 --- a/src/shared/config.c +++ b/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; diff --git a/src/shared/config.h b/src/shared/config.h index e6a525d..213cb93 100644 --- a/src/shared/config.h +++ b/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, diff --git a/src/shared/data.c b/src/shared/data.c index e0e3156..82e6198 100644 --- a/src/shared/data.c +++ b/src/shared/data.c @@ -1,6 +1,6 @@ #include "data.h" #include "log.h" -#include "stdlib.h" +#include Data* data_create_empty(size_t data_size) { /* malloc(0) is UB; allocate at least 1 byte but preserve requested size */ diff --git a/src/shared/file.c b/src/shared/file.c index 5a412cd..2d9f922 100644 --- a/src/shared/file.c +++ b/src/shared/file.c @@ -1,7 +1,9 @@ #include +#include #include #include #include +#include #include #include #include @@ -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; diff --git a/src/shared/log.c b/src/shared/log.c index bc8ffed..bb7590a 100644 --- a/src/shared/log.c +++ b/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]); diff --git a/src/shared/metadata.c b/src/shared/metadata.c index b4de62e..4134c13 100644 --- a/src/shared/metadata.c +++ b/src/shared/metadata.c @@ -11,6 +11,19 @@ #include #include +/* + * 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)); diff --git a/src/shared/metadata.h b/src/shared/metadata.h index 518077b..28312f5 100644 --- a/src/shared/metadata.h +++ b/src/shared/metadata.h @@ -6,6 +6,23 @@ #include #include +/* + * 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); diff --git a/src/shared/protocol.c b/src/shared/protocol.c index f07b8a1..62f18cf 100644 --- a/src/shared/protocol.c +++ b/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); } diff --git a/src/shared/transport_ssh.c b/src/shared/transport_ssh.c index 9b7950e..377fa63 100644 --- a/src/shared/transport_ssh.c +++ b/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*)); diff --git a/src/shared/utils.c b/src/shared/utils.c index 680a6b2..a5b67cd 100644 --- a/src/shared/utils.c +++ b/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; } diff --git a/src/shared/utils.h b/src/shared/utils.h index 13cd999..1cc8a6c 100644 --- a/src/shared/utils.h +++ b/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); diff --git a/tests/test_protocol.c b/tests/test_protocol.c index f644032..f60d45f 100644 --- a/tests/test_protocol.c +++ b/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]); diff --git a/tests/test_scanner.c b/tests/test_scanner.c index 4c6048c..e9bd87f 100644 --- a/tests/test_scanner.c +++ b/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");