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

@@ -10,7 +10,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-char *server_host = "127.0.0.1";
+char* server_host = "127.0.0.1";
 int server_port = 8080;
 
 static void print_usage(void) {
@@ -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;
   }
 

src/client/client_send.c

@@ -19,20 +19,26 @@
 #include <threads.h>
 #include <time.h>
 
-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;

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

src/client/scanner.c

@@ -11,8 +11,12 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-DirectoryScanner *directory_scanner_create(char *root_directory, bool use_metadata, unsigned long long chunk_size, char **exclude_patterns, int exclude_count, char **include_patterns, int include_count, unsigned long long max_size, unsigned long long min_size) {
-  DirectoryScanner *scanner = malloc(sizeof(DirectoryScanner));
+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;

src/client/scanner.h

@@ -7,21 +7,25 @@
 #include <stdbool.h>
 
 typedef struct {
-  Queue *directories;
-  DIR *current_dir;
-  char *current_path;
+  Queue* directories;
+  DIR* current_dir;
+  char* current_path;
   bool use_metadata;
   unsigned long long chunk_size;
-  char **exclude_patterns;
+  char** exclude_patterns;
   int exclude_count;
-  char **include_patterns;
+  char** include_patterns;
   int include_count;
   unsigned long long max_size;
   unsigned long long min_size;
 } DirectoryScanner;
 
-DirectoryScanner *directory_scanner_create(char *root_directory, bool use_metadata, unsigned long long chunk_size, char **exclude_patterns, int exclude_count, char **include_patterns, int include_count, unsigned long long max_size, unsigned long long min_size);
-Chunk *directory_scanner_next(DirectoryScanner *scanner);
-void directory_scanner_destroy(DirectoryScanner *scanner);
+DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metadata,
+                                           unsigned long long chunk_size, char** exclude_patterns,
+                                           int exclude_count, char** include_patterns,
+                                           int include_count, unsigned long long max_size,
+                                           unsigned long long min_size);
+Chunk* directory_scanner_next(DirectoryScanner* scanner);
+void directory_scanner_destroy(DirectoryScanner* scanner);
 
 #endif