From 23b1d6660c9dfd0484fd764036f3f80e177926f2 Mon Sep 17 00:00:00 2001 From: TapTap Date: Sun, 19 Jul 2026 15:57:31 +0200 Subject: [PATCH] fix: reformat codebase and fix const-correctness for CI lint - Reformat all C/H files to match .clang-format (LLVM style) - Fix 26 cppcheck const-correctness warnings (constParameterPointer, constVariablePointer, constVariable) - Update function declarations in headers to match const parameters --- src/client/client_cli.c | 37 +++--- src/client/client_send.c | 225 ++++++++++++++++++----------------- src/client/client_send.h | 8 +- src/client/scanner.c | 32 ++--- src/client/scanner.h | 20 ++-- src/server/server.c | 39 +++--- src/shared/array_list.c | 26 ++-- src/shared/array_list.h | 14 +-- src/shared/chunk.c | 66 +++++----- src/shared/chunk.h | 14 +-- src/shared/compression.c | 35 +++--- src/shared/compression.h | 4 +- src/shared/config.c | 147 ++++++++++++++--------- src/shared/config.h | 43 +++---- src/shared/data.c | 17 +-- src/shared/data.h | 10 +- src/shared/file.c | 147 ++++++++++++++--------- src/shared/file.h | 33 ++--- src/shared/log.c | 11 +- src/shared/log.h | 9 +- src/shared/metadata.c | 62 ++++++---- src/shared/metadata.h | 13 +- src/shared/multiprocessing.c | 77 ++++++------ src/shared/multiprocessing.h | 28 ++--- src/shared/protocol.c | 72 ++++++----- src/shared/protocol.h | 28 +++-- src/shared/queue.c | 44 +++---- src/shared/queue.h | 27 ++--- src/shared/transport_ssh.c | 39 +++--- src/shared/transport_ssh.h | 2 +- src/shared/transport_tcp.c | 60 +++++----- src/shared/transport_tcp.h | 24 ++-- src/shared/transport_tls.c | 59 +++++---- src/shared/transport_tls.h | 11 +- src/shared/utils.c | 50 ++++---- src/shared/utils.h | 10 +- tests/test_array_list.c | 22 ++-- tests/test_chunk.c | 26 ++-- tests/test_compression.c | 40 +++---- tests/test_config.c | 34 +++--- tests/test_queue.c | 71 ++++++----- tests/test_scanner.c | 62 +++++----- tests/test_shared_utils.c | 42 +++---- tests/test_utils.h | 136 +++++++++++---------- 44 files changed, 1053 insertions(+), 923 deletions(-) diff --git a/src/client/client_cli.c b/src/client/client_cli.c index 1a046e9..55b510e 100644 --- a/src/client/client_cli.c +++ b/src/client/client_cli.c @@ -10,7 +10,7 @@ #include #include -char *server_host = "127.0.0.1"; +char* server_host = "127.0.0.1"; int server_port = 8080; static void print_usage(void) { @@ -55,19 +55,18 @@ 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; @@ -89,11 +88,13 @@ 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); @@ -105,12 +106,11 @@ 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++; } } @@ -140,7 +140,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) { @@ -201,9 +201,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) { @@ -212,7 +212,8 @@ 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; } diff --git a/src/client/client_send.c b/src/client/client_send.c index 44c66c2..a832f51 100644 --- a/src/client/client_send.c +++ b/src/client/client_send.c @@ -19,20 +19,26 @@ #include #include -static int incremental_check(Client *client, File *file) { - if (!send_status(client->file_descriptor, STATUS_CHECK)) return -1; - if (!send_str(client->file_descriptor, file->path)) return -1; +static int incremental_check(Client* client, File* file) { + 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_NEXT) { log_message(LOG_LEVEL_ERROR, "Unexpected server status"); return -1; @@ -40,29 +46,39 @@ static int incremental_check(Client *client, File *file) { 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 = incremental_check(client, chunk->items[i]); - if (rc < 0) return -1; - if (rc > 0) continue; - if (!file_send_sendfile(chunk->items[i], client->file_descriptor, config->use_metadata, false)) + if (rc < 0) + return -1; + if (rc > 0) + continue; + if (!file_send_sendfile(chunk->items[i], client->file_descriptor, config->use_metadata, + false)) 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, true)) + if (!send_status(client->file_descriptor, STATUS_NEXT)) + return -1; + if (!file_send_sendfile(chunk->items[i], client->file_descriptor, config->use_metadata, + true)) return -1; } } @@ -70,19 +86,18 @@ int send_chunk(Client *client, Chunk *chunk, Config *config) { for (int i = 0; i < chunk->element_count; i++) { if (config->use_incremental) { int rc = incremental_check(client, chunk->items[i]); - if (rc < 0) return -1; - if (rc > 0) continue; - if (!file_send_single_calls(chunk->items[i], client->file_descriptor, - config->use_metadata, - config->use_compression ? config->compression_level : 0, - false)) + if (rc < 0) + return -1; + if (rc > 0) + continue; + if (!file_send_single_calls(chunk->items[i], client->file_descriptor, config->use_metadata, + config->use_compression ? config->compression_level : 0, false)) 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; } } @@ -90,9 +105,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"); @@ -101,18 +116,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; } @@ -124,17 +139,15 @@ 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; @@ -153,30 +166,29 @@ 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); } @@ -189,12 +201,11 @@ 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); @@ -212,60 +223,58 @@ 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; } @@ -275,23 +284,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)); } } @@ -325,7 +334,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); @@ -342,41 +351,39 @@ 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); @@ -386,11 +393,9 @@ 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; diff --git a/src/client/client_send.h b/src/client/client_send.h index 132cb15..83e9e00 100644 --- a/src/client/client_send.h +++ b/src/client/client_send.h @@ -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 diff --git a/src/client/scanner.c b/src/client/scanner.c index c62f166..cf67765 100644 --- a/src/client/scanner.c +++ b/src/client/scanner.c @@ -11,8 +11,12 @@ #include #include -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)); +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; @@ -28,7 +32,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) { @@ -40,16 +44,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; @@ -59,7 +63,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"); @@ -70,8 +74,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) { @@ -80,7 +84,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; @@ -92,7 +96,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); @@ -100,7 +104,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++) { @@ -134,7 +138,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; diff --git a/src/client/scanner.h b/src/client/scanner.h index 76361bd..8202d61 100644 --- a/src/client/scanner.h +++ b/src/client/scanner.h @@ -7,21 +7,25 @@ #include 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 diff --git a/src/server/server.c b/src/server/server.c index 8c5af91..d3bbc74 100644 --- a/src/server/server.c +++ b/src/server/server.c @@ -16,21 +16,24 @@ #include #include -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; @@ -41,7 +44,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); @@ -59,7 +62,8 @@ 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"); @@ -71,21 +75,20 @@ 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); @@ -109,7 +112,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; @@ -134,11 +137,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); @@ -161,7 +164,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]); diff --git a/src/shared/array_list.c b/src/shared/array_list.c index 4aa9a68..4df49d0 100644 --- a/src/shared/array_list.c +++ b/src/shared/array_list.c @@ -3,14 +3,14 @@ #include #include -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,12 +34,13 @@ 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; @@ -49,8 +50,9 @@ 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; @@ -60,15 +62,15 @@ bool array_list_add(ArrayList *array_list, void *item) { return true; } -void **array_list_to_array(ArrayList *array_list) { +void** array_list_to_array(const 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; } diff --git a/src/shared/array_list.h b/src/shared/array_list.h index 4e8932c..9ecbe0b 100644 --- a/src/shared/array_list.h +++ b/src/shared/array_list.h @@ -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(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(const ArrayList* array_list); #endif diff --git a/src/shared/chunk.c b/src/shared/chunk.c index 18b7edc..611f650 100644 --- a/src/shared/chunk.c +++ b/src/shared/chunk.c @@ -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,26 +46,25 @@ 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); @@ -84,9 +83,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) { @@ -96,7 +95,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); @@ -106,7 +105,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); @@ -117,7 +116,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) { @@ -133,7 +132,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); @@ -143,7 +142,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); @@ -158,8 +157,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; @@ -168,24 +167,26 @@ 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, Config *config) { - Data *chunk_data = receive_data(fd); +Chunk* receive_chunk_data(int fd, const 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); @@ -194,12 +195,9 @@ Chunk *receive_chunk_data(int fd, 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; } - - - diff --git a/src/shared/chunk.h b/src/shared/chunk.h index fc07792..dbba7b7 100644 --- a/src/shared/chunk.h +++ b/src/shared/chunk.h @@ -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, 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, const Config* config); #endif diff --git a/src/shared/compression.c b/src/shared/compression.c index 76a2c1b..aa27ecb 100644 --- a/src/shared/compression.c +++ b/src/shared/compression.c @@ -6,14 +6,15 @@ #define INITIAL_DECOMPRESS_BUF_SIZE (1024 * 1024) -Data *data_compress(Data *data_to_compress, int compression_level) { +Data* data_compress(Data* data_to_compress, int compression_level) { (void)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); @@ -27,8 +28,7 @@ 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,27 +43,25 @@ 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); @@ -77,15 +75,14 @@ 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); diff --git a/src/shared/compression.h b/src/shared/compression.h index d902cfa..dcf30dd 100644 --- a/src/shared/compression.h +++ b/src/shared/compression.h @@ -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 diff --git a/src/shared/config.c b/src/shared/config.c index 6b585d7..f99987f 100644 --- a/src/shared/config.c +++ b/src/shared/config.c @@ -7,14 +7,12 @@ #include #include -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; @@ -46,28 +44,33 @@ Config *config_create(char *version, char *send_directory, 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); - char *colon = strchr(config->receive_root_directory, ':'); - char *path = str_dup(colon + 1); + const 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); @@ -84,22 +87,36 @@ void config_delete(Config *config) { free(config); } -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; +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; 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; @@ -107,43 +124,66 @@ bool config_send(int file_descriptor, 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; config->show_progress = false; config->dry_run = false; @@ -160,7 +200,8 @@ 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: diff --git a/src/shared/config.h b/src/shared/config.h index 050ef4c..68d652d 100644 --- a/src/shared/config.h +++ b/src/shared/config.h @@ -3,15 +3,12 @@ #include -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; @@ -25,33 +22,31 @@ 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; bool use_incremental; 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.1.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, 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 diff --git a/src/shared/data.c b/src/shared/data.c index ae1e744..5b3dcba 100644 --- a/src/shared/data.c +++ b/src/shared/data.c @@ -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,8 +34,9 @@ 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); } diff --git a/src/shared/data.h b/src/shared/data.h index 53ed762..5246afa 100644 --- a/src/shared/data.h +++ b/src/shared/data.h @@ -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 diff --git a/src/shared/file.c b/src/shared/file.c index 20337aa..d617b05 100644 --- a/src/shared/file.c +++ b/src/shared/file.c @@ -19,15 +19,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; @@ -44,10 +44,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); @@ -57,8 +57,8 @@ void file_destroy(void *item) { free(file); } -FileMetadata *file_metadata_create(struct stat *stats) { - FileMetadata *m = malloc(sizeof(FileMetadata)); +FileMetadata* file_metadata_create(const struct stat* stats) { + FileMetadata* m = malloc(sizeof(FileMetadata)); if (m == NULL) { perror("ERROR: Could not allocate memory for file metadata"); return NULL; @@ -75,12 +75,13 @@ FileMetadata *file_metadata_create(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) { @@ -96,9 +97,10 @@ 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) { - 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) { @@ -123,18 +125,24 @@ 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; } -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; } +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; + } unsigned long long check_size; long long check_mtime; @@ -145,36 +153,48 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipp 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 match = false; - if (full_path && stat(full_path, &st) == 0 && - (unsigned long long)st.st_size == check_size && + if (full_path && stat(full_path, &st) == 0 && (unsigned long long)st.st_size == check_size && (long long)st.st_mtime == check_mtime) { match = true; } free(full_path); if (match) { - if (!send_status(fd, STATUS_OK)) { free(check_path); return NULL; } + if (!send_status(fd, STATUS_OK)) { + free(check_path); + return NULL; + } free(check_path); *skipped = true; return NULL; } - if (!send_status(fd, STATUS_NEXT)) { free(check_path); return NULL; } + if (!send_status(fd, STATUS_NEXT)) { + free(check_path); + return NULL; + } - File *file = file_create(check_path); + File* file = file_create(check_path); free(check_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); @@ -182,9 +202,13 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipp } 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; } @@ -193,15 +217,15 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipp 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); @@ -218,9 +242,11 @@ 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, bool send_path) { - if (send_path && !send_str(file_descriptor, file->path)) return false; - if (use_metadata && !metadata_send(file_descriptor, file->metadata)) return false; +bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, bool send_path) { + 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) { @@ -248,24 +274,29 @@ bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, bool return true; } -File *file_receive(Config *config, int file_descriptor) { - char *path = receive_str(file_descriptor); - if (path == NULL) return NULL; - File *file = file_create(path); +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); 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); @@ -278,14 +309,13 @@ File *file_receive(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!"); @@ -295,21 +325,22 @@ size_t file_content_to_buffer(File *file) { return bytes_read; } -int receive_manifest(int fd, Config *config, int *next_status) { +int receive_manifest(int fd, const 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; } - - diff --git a/src/shared/file.h b/src/shared/file.h index 9256918..088bd06 100644 --- a/src/shared/file.h +++ b/src/shared/file.h @@ -15,23 +15,24 @@ 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(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, 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); +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, 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, Config* config, bool* skipped); +int receive_manifest(int fd, const Config* config, int* next_status); #endif diff --git a/src/shared/log.c b/src/shared/log.c index 953a117..bcf91bf 100644 --- a/src/shared/log.c +++ b/src/shared/log.c @@ -3,22 +3,21 @@ #include #include -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); - struct tm *t = localtime(&now); + const 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); diff --git a/src/shared/log.h b/src/shared/log.h index 1510b6b..ccff5dc 100644 --- a/src/shared/log.h +++ b/src/shared/log.h @@ -1,14 +1,9 @@ #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 diff --git a/src/shared/metadata.c b/src/shared/metadata.c index 6ca6c43..b1dbb57 100644 --- a/src/shared/metadata.c +++ b/src/shared/metadata.c @@ -8,35 +8,45 @@ #include #include -void metadata_to_buf(char **buf, FileMetadata *m) { +void metadata_to_buf(char** buf, const 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)); @@ -50,32 +60,40 @@ 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; + if (ok) + *ok = 1; + return NULL; + } + FileMetadata* m = malloc(sizeof(FileMetadata)); + if (m == NULL) { + if (ok) + *ok = 0; 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); diff --git a/src/shared/metadata.h b/src/shared/metadata.h index 0107c56..2ad8b3d 100644 --- a/src/shared/metadata.h +++ b/src/shared/metadata.h @@ -5,12 +5,13 @@ #include #include -#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, 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, 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); #endif diff --git a/src/shared/multiprocessing.c b/src/shared/multiprocessing.c index ffb6148..cebc020 100644 --- a/src/shared/multiprocessing.c +++ b/src/shared/multiprocessing.c @@ -13,11 +13,11 @@ #include #include -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, 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, 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; - 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,18 +140,17 @@ 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; diff --git a/src/shared/multiprocessing.h b/src/shared/multiprocessing.h index 605c42a..1b9032d 100644 --- a/src/shared/multiprocessing.h +++ b/src/shared/multiprocessing.h @@ -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,14 +33,12 @@ 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 diff --git a/src/shared/protocol.c b/src/shared/protocol.c index 1e121a7..a372d4e 100644 --- a/src/shared/protocol.c +++ b/src/shared/protocol.c @@ -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,13 +28,14 @@ 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); @@ -56,7 +57,7 @@ static void bw_throttle(size_t bytes_written) { } } -void io_set_ssl(SSL *ssl) { +void io_set_ssl(SSL* ssl) { io_ssl = ssl; } @@ -64,7 +65,7 @@ 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, 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; @@ -74,9 +75,9 @@ bool send_n_data(int file_descriptor, void *data, size_t data_size) { chunk = 65536; ssize_t bytes_send; if (io_ssl) - bytes_send = SSL_write(io_ssl, (char *)data + total_bytes_send, chunk); + bytes_send = SSL_write(io_ssl, (char*)data + total_bytes_send, chunk); else - bytes_send = write(fd, (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; @@ -88,18 +89,18 @@ bool send_n_data(int file_descriptor, 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"); @@ -113,7 +114,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"; @@ -132,19 +133,23 @@ static const char *status_to_string(Status status) { } } -bool send_str(int file_descriptor, 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; @@ -154,7 +159,7 @@ char *receive_str(int file_descriptor) { return data; } -bool send_data(int file_descriptor, 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; @@ -164,12 +169,13 @@ bool send_data(int file_descriptor, 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; @@ -179,25 +185,29 @@ 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; } diff --git a/src/shared/protocol.h b/src/shared/protocol.h index 27f8d8d..ec3b13d 100644 --- a/src/shared/protocol.h +++ b/src/shared/protocol.h @@ -8,22 +8,30 @@ 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 }; +enum NET_STATUS { + STATUS_OK, + STATUS_ERROR, + STATUS_FINISHED, + STATUS_NEXT, + STATUS_CHUNK, + STATUS_MANIFEST, + STATUS_CHECK +}; void io_set_fds(int read_fd, int write_fd); void io_set_bwlimit(unsigned long long bytes_per_sec); 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); +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, char *data); -char *receive_str(int file_descriptor); -bool send_data(int file_descriptor, 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 diff --git a/src/shared/queue.c b/src/shared/queue.c index ef78580..ec7c365 100644 --- a/src/shared/queue.c +++ b/src/shared/queue.c @@ -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,24 +46,25 @@ void queue_destroy(Queue *queue) { free(queue); } -bool queue_is_empty(Queue *queue) { +bool queue_is_empty(const Queue* queue) { if (queue == NULL) return true; return queue->size == 0; } -bool queue_is_full(Queue *queue) { +bool queue_is_full(const 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; @@ -78,10 +79,12 @@ 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; @@ -89,9 +92,8 @@ 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); @@ -101,23 +103,21 @@ bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex, 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, - bool *other_thread_done) { +void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty, + cnd_t* condition_not_full, const 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, 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; diff --git a/src/shared/queue.h b/src/shared/queue.h index 3c99f12..2faeb03 100644 --- a/src/shared/queue.h +++ b/src/shared/queue.h @@ -5,26 +5,23 @@ #include 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(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); +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); #endif diff --git a/src/shared/transport_ssh.c b/src/shared/transport_ssh.c index 63273ad..9eb5264 100644 --- a/src/shared/transport_ssh.c +++ b/src/shared/transport_ssh.c @@ -13,36 +13,41 @@ 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(char *destination, int port) { +Client* client_connect_ssh(const char* destination, int port) { RemoteDest r; if (parse_remote_dest(destination, &r) != 0) { fprintf(stderr, "Invalid remote destination: %s\n", destination); @@ -64,15 +69,18 @@ Client *client_connect_ssh(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; } @@ -85,7 +93,8 @@ Client *client_connect_ssh(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') @@ -93,7 +102,7 @@ Client *client_connect_ssh(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"; @@ -133,7 +142,7 @@ Client *client_connect_ssh(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); diff --git a/src/shared/transport_ssh.h b/src/shared/transport_ssh.h index f542870..d6b9845 100644 --- a/src/shared/transport_ssh.h +++ b/src/shared/transport_ssh.h @@ -3,6 +3,6 @@ #include "transport_tcp.h" -Client *client_connect_ssh(char *destination, int port); +Client* client_connect_ssh(const char* destination, int port); #endif diff --git a/src/shared/transport_tcp.c b/src/shared/transport_tcp.c index 2050ea2..c06278b 100644 --- a/src/shared/transport_tcp.c +++ b/src/shared/transport_tcp.c @@ -11,8 +11,8 @@ #include #include -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,8 +26,7 @@ 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); @@ -40,8 +39,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); @@ -51,8 +50,9 @@ 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,8 +72,7 @@ static void accept_loop(Server *server, void (*child_fn)(int, void *), 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; @@ -90,35 +89,35 @@ static void accept_loop(Server *server, void (*child_fn)(int, void *), } } -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; @@ -132,7 +131,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) { @@ -140,15 +139,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); @@ -163,8 +162,9 @@ 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; diff --git a/src/shared/transport_tcp.h b/src/shared/transport_tcp.h index b176c18..0c4b7da 100644 --- a/src/shared/transport_tcp.h +++ b/src/shared/transport_tcp.h @@ -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 diff --git a/src/shared/transport_tls.c b/src/shared/transport_tls.c index 2c9423f..4ce19a4 100644 --- a/src/shared/transport_tls.c +++ b/src/shared/transport_tls.c @@ -31,11 +31,10 @@ 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(); @@ -58,8 +57,7 @@ static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert, 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; } @@ -79,8 +77,8 @@ static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert, 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; @@ -93,8 +91,7 @@ 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; @@ -102,23 +99,25 @@ 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); @@ -126,31 +125,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; diff --git a/src/shared/transport_tls.h b/src/shared/transport_tls.h index c04333f..b9d59e7 100644 --- a/src/shared/transport_tls.h +++ b/src/shared/transport_tls.h @@ -6,11 +6,10 @@ 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 diff --git a/src/shared/utils.c b/src/shared/utils.c index 98bc368..0846e72 100644 --- a/src/shared/utils.c +++ b/src/shared/utils.c @@ -8,21 +8,25 @@ #include #include -bool mkdir_r(char *path) { - char *path_duplicate = malloc(strlen(path) + 1); - if (!path_duplicate) return false; +bool mkdir_r(const 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 = "/"; - char *part = strtok(path_duplicate, delimiter); + const char* delimiter = "/"; + const char* part = strtok(path_duplicate, delimiter); bool ok = true; while (part != NULL) { strcpy(path_current_position, part); @@ -44,15 +48,15 @@ bool mkdir_r(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++; @@ -77,17 +81,16 @@ 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); @@ -100,7 +103,7 @@ static void delete_extras_walk(const char *abs_path, const char *rel_path, // 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; } @@ -117,26 +120,27 @@ static void delete_extras_walk(const char *abs_path, const char *rel_path, 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(char *path1, char *path2) { +char* path_cat(const 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); diff --git a/src/shared/utils.h b/src/shared/utils.h index 7e227c3..13cd999 100644 --- a/src/shared/utils.h +++ b/src/shared/utils.h @@ -4,10 +4,10 @@ #include "array_list.h" #include -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); +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); #endif diff --git a/tests/test_array_list.c b/tests/test_array_list.c index d7bc9ea..1bf05d9 100644 --- a/tests/test_array_list.c +++ b/tests/test_array_list.c @@ -4,28 +4,28 @@ #include 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 diff --git a/tests/test_chunk.c b/tests/test_chunk.c index 024e729..63400d4 100644 --- a/tests/test_chunk.c +++ b/tests/test_chunk.c @@ -7,13 +7,13 @@ #include 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); diff --git a/tests/test_compression.c b/tests/test_compression.c index 46ab006..08d8615 100644 --- a/tests/test_compression.c +++ b/tests/test_compression.c @@ -9,18 +9,18 @@ #include static void test_data_compress_decompress_roundtrip() { - char original[] = "Hello, World! This is test data for compression round-trip!"; + const 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); diff --git a/tests/test_config.c b/tests/test_config.c index df71e3a..2dad898 100644 --- a/tests/test_config.c +++ b/tests/test_config.c @@ -7,8 +7,8 @@ #include 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); diff --git a/tests/test_queue.c b/tests/test_queue.c index e04e997..c392fcb 100644 --- a/tests/test_queue.c +++ b/tests/test_queue.c @@ -7,12 +7,12 @@ #include 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); - int expected_vals[] = {30, 40, 50, 60, 70, 80}; + const 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,34 +69,34 @@ static void test_queue_resize() { EXPECT_TRUE(queue_is_full(q)); - int *v1 = (int *)queue_dequeue(q); + const int* v1 = (const int*)queue_dequeue(q); EXPECT_NOT_NULL(v1); EXPECT_EQ_INT(*v1, 1); // Now front = 1, rear = 0, size = 2 (wrapped state) - queue_enqueue(q, &d); + queue_enqueue(q, &d); EXPECT_TRUE(queue_is_full(q)); // This enqueue triggers capacity doubling - queue_enqueue(q, &e); + queue_enqueue(q, &e); EXPECT_FALSE(queue_is_full(q)); EXPECT_EQ_INT(q->capacity, 6); EXPECT_EQ_INT(q->size, 4); // Dequeue all and check order: B, C, D, E - int *v2 = (int *)queue_dequeue(q); + const int* v2 = (const int*)queue_dequeue(q); EXPECT_NOT_NULL(v2); EXPECT_EQ_INT(*v2, 2); - int *v3 = (int *)queue_dequeue(q); + const int* v3 = (const int*)queue_dequeue(q); EXPECT_NOT_NULL(v3); EXPECT_EQ_INT(*v3, 3); - int *v4 = (int *)queue_dequeue(q); + const int* v4 = (const int*)queue_dequeue(q); EXPECT_NOT_NULL(v4); EXPECT_EQ_INT(*v4, 4); - int *v5 = (int *)queue_dequeue(q); + const int* v5 = (const 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,18 +131,19 @@ 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; } @@ -153,7 +154,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; @@ -162,21 +163,19 @@ 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); } diff --git a/tests/test_scanner.c b/tests/test_scanner.c index 76bb8a7..7920e0a 100644 --- a/tests/test_scanner.c +++ b/tests/test_scanner.c @@ -6,27 +6,28 @@ #include #include -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); - Chunk *next = directory_scanner_next(scanner); + const Chunk* next = directory_scanner_next(scanner); EXPECT_NULL(next); chunk_destroy(chunk); @@ -36,35 +37,38 @@ 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); - Chunk *chunk = directory_scanner_next(scanner); + const 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); - Chunk *next = directory_scanner_next(scanner); + const Chunk* next = directory_scanner_next(scanner); EXPECT_NULL(next); - chunk_destroy(chunk); + chunk_destroy((void*)chunk); directory_scanner_destroy(scanner); unlink(file1); unlink(file2); @@ -72,22 +76,23 @@ 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); @@ -102,14 +107,15 @@ 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); - Chunk *chunk = directory_scanner_next(scanner); + const Chunk* chunk = directory_scanner_next(scanner); EXPECT_NULL(chunk); directory_scanner_destroy(scanner); diff --git a/tests/test_shared_utils.c b/tests/test_shared_utils.c index 3470d8b..57b1c74 100644 --- a/tests/test_shared_utils.c +++ b/tests/test_shared_utils.c @@ -6,56 +6,56 @@ void test_shared_utils() { // Test str_dup - char *dup_null = str_dup(NULL); + const 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); diff --git a/tests/test_utils.h b/tests/test_utils.h index dda6bb6..c9e9f02 100644 --- a/tests/test_utils.h +++ b/tests/test_utils.h @@ -11,84 +11,90 @@ 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