refactor: config_create(), main(), send_files() - reduce duplication and complexity

- #150: Replace 11-parameter config_create() with config_create() that
  initializes to sensible defaults; callers set fields directly
- #149: Extract validate_config() from main(); reduce main() from 325 to
  281 lines by extracting validation logic into separate function
- #151: Extract run_dry_run(), connect_to_server(), send_manifest(), and
  print_progress() shared helpers from send_files()/send_files_multithreaded()
  to eliminate code duplication

src/client/client_cli.c

@@ -99,39 +99,77 @@ static int read_patterns_from_file(const char* filepath, char*** patterns, int*
       return -1;
     }
     *patterns = tmp;
-    (*patterns)[*count] = str_dup(p);
+    (*patterns)[(*count)++] = str_dup(p);
-    if (!(*patterns)[*count]) {
-      fprintf(stderr, "Error: memory allocation failed for pattern\n");
-      fclose(fp);
-      return -1;
-    }
-    (*count)++;
   }
   fclose(fp);
   return 0;
 }
 
+static bool validate_config(Config* config) {
+  if (!config->send_directory || !config->receive_root_directory) {
+    fprintf(stderr, "Error: source and destination directories are required\n");
+    print_usage();
+    return false;
+  }
+  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");
+    return false;
+  }
+  if (config->transport == TRANSPORT_SSH && config->use_sendfile) {
+    fprintf(stderr, "Error: -f/--sendfile is not supported with SSH transport\n");
+    return false;
+  }
+  if (config->use_incremental && config->use_chunk_serialization) {
+    fprintf(stderr, "Error: --incremental is not supported with -s (chunk serialization)\n");
+    return false;
+  }
+  if (config->use_incremental && !config->use_metadata) {
+    log_message(LOG_LEVEL_INFO, "Enabling metadata preservation for --incremental");
+    config->use_metadata = true;
+  }
+  if (config->use_delta && !config->use_incremental) {
+    fprintf(stderr, "Error: --delta requires --incremental\n");
+    return false;
+  }
+  if (config->use_delta && config->use_chunk_serialization) {
+    fprintf(stderr, "Error: --delta cannot be combined with -s (chunk serialization)\n");
+    return false;
+  }
+  if (config->use_delta && config->use_sendfile) {
+    fprintf(stderr, "Error: --delta cannot be combined with -f (sendfile)\n");
+    return false;
+  }
+  if (config->use_delta && !config->use_metadata) {
+    log_message(LOG_LEVEL_INFO, "Enabling metadata preservation for --delta");
+    config->use_metadata = true;
+  }
+  if (config->use_tls) {
+    if (!config->tls_cert || !config->tls_key) {
+      fprintf(stderr, "Error: --tls requires --cert and --key\n");
+      return false;
+    }
+    tls_global_init();
+  }
+  return true;
+}
+
 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)) {
-    save_to_disk = true;
-  }
-
   int exit_code = 0;
   Config* config = NULL;
   bool config_owned_by_pipeline = false;
 
-  char* config_version = str_dup(PROTOCOL_VERSION);
+  config = config_create();
-  if (!config_version) {
+  if (!config) {
     exit_code = 1;
     goto cleanup;
   }
-  config = config_create(config_version, NULL, NULL, save_to_disk, false, false, false, false, 5,
+  if (env_save && (strcmp(env_save, "true") == 0 || strcmp(env_save, "1") == 0))
-                         false, 0);
+    config->save_to_disk = true;
 
   int positional_args[2];
   int positional_count = 0;
@@ -148,15 +186,7 @@ int main(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "-n") == 0 || strcmp(argv[i], "--dry-run") == 0) {
       config->dry_run = true;
     } else if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
-      char* end;
+      config->ssh_port = atoi(argv[++i]);
-      errno = 0;
-      long val = strtol(argv[++i], &end, 10);
-      if (errno != 0 || *end != '\0' || val <= 0 || val > 65535) {
-        fprintf(stderr, "Error: -p must be a valid port number (1-65535)\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-      config->ssh_port = (int)val;
     } else if (strcmp(argv[i], "--delete") == 0) {
       config->use_delete = true;
     } else if (strcmp(argv[i], "--exclude") == 0 && i + 1 < argc) {
@@ -167,13 +197,7 @@ int main(int argc, char* argv[]) {
         goto cleanup;
       }
       config->exclude_patterns = tmp;
-      config->exclude_patterns[config->exclude_count] = str_dup(argv[++i]);
+      config->exclude_patterns[config->exclude_count++] = str_dup(argv[++i]);
-      if (!config->exclude_patterns[config->exclude_count]) {
-        fprintf(stderr, "Error: memory allocation failed for exclude pattern\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-      config->exclude_count++;
     } else if (strcmp(argv[i], "--include") == 0 && i + 1 < argc) {
       char** tmp = realloc(config->include_patterns, (config->include_count + 1) * sizeof(char*));
       if (!tmp) {
@@ -182,31 +206,11 @@ int main(int argc, char* argv[]) {
         goto cleanup;
       }
       config->include_patterns = tmp;
-      config->include_patterns[config->include_count] = str_dup(argv[++i]);
+      config->include_patterns[config->include_count++] = str_dup(argv[++i]);
-      if (!config->include_patterns[config->include_count]) {
-        fprintf(stderr, "Error: memory allocation failed for include pattern\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-      config->include_count++;
     } else if (strcmp(argv[i], "--max-size") == 0 && i + 1 < argc) {
-      char* end;
+      config->max_size = strtoull(argv[++i], NULL, 10);
-      errno = 0;
-      config->max_size = strtoull(argv[++i], &end, 10);
-      if (errno != 0 || *end != '\0') {
-        fprintf(stderr, "Error: --max-size must be a valid non-negative integer\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "--min-size") == 0 && i + 1 < argc) {
-      char* end;
+      config->min_size = strtoull(argv[++i], NULL, 10);
-      errno = 0;
-      config->min_size = strtoull(argv[++i], &end, 10);
-      if (errno != 0 || *end != '\0') {
-        fprintf(stderr, "Error: --min-size must be a valid non-negative integer\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "--incremental") == 0) {
       config->use_incremental = true;
     } else if (strcmp(argv[i], "--delta") == 0) {
@@ -238,19 +242,9 @@ int main(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "--source-dir") == 0 && i + 1 < argc) {
       free(config->send_directory);
       config->send_directory = str_dup(argv[++i]);
-      if (!config->send_directory) {
-        fprintf(stderr, "Error: memory allocation failed\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "--dest-dir") == 0 && i + 1 < argc) {
       free(config->receive_root_directory);
       config->receive_root_directory = str_dup(argv[++i]);
-      if (!config->receive_root_directory) {
-        fprintf(stderr, "Error: memory allocation failed\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "--save-to-disk") == 0) {
       config->save_to_disk = true;
     } else if (strcmp(argv[i], "-M") == 0 || strcmp(argv[i], "--preserve") == 0) {
@@ -268,21 +262,8 @@ int main(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "--server-host") == 0 && i + 1 < argc) {
       free(config->server_host);
       config->server_host = str_dup(argv[++i]);
-      if (!config->server_host) {
-        fprintf(stderr, "Error: memory allocation failed\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "--server-port") == 0 && i + 1 < argc) {
-      char* end;
+      config->server_port = atoi(argv[++i]);
-      errno = 0;
-      long val = strtol(argv[++i], &end, 10);
-      if (errno != 0 || *end != '\0' || val <= 0 || val > 65535) {
-        fprintf(stderr, "Error: --server-port must be a valid port number (1-65535)\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-      config->server_port = (int)val;
     } else if (strcmp(argv[i], "--bwlimit") == 0 && i + 1 < argc) {
       char* end;
       errno = 0;
@@ -337,11 +318,6 @@ int main(int argc, char* argv[]) {
       config->backup = true;
     } else if (strcmp(argv[i], "--backup-dir") == 0 && i + 1 < argc) {
       config->backup_dir = str_dup(argv[++i]);
-      if (!config->backup_dir) {
-        fprintf(stderr, "Error: memory allocation failed\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "--stats") == 0) {
       config->stats = true;
     } else if (strcmp(argv[i], "--max-depth") == 0 && i + 1 < argc) {
@@ -384,11 +360,6 @@ int main(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "--fastsync-server-path") == 0 && i + 1 < argc) {
       free(config->fastsync_server_path);
       config->fastsync_server_path = str_dup(argv[++i]);
-      if (!config->fastsync_server_path) {
-        fprintf(stderr, "Error: memory allocation failed\n");
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
       set_log_level(LOG_LEVEL_DEBUG);
     } else if (argv[i][0] == '-') {
@@ -413,13 +384,7 @@ int main(int argc, char* argv[]) {
     free(config->receive_root_directory);
     config->send_directory = str_dup(argv[positional_args[0]]);
     config->receive_root_directory = str_dup(argv[positional_args[1]]);
-    if (!config->send_directory || !config->receive_root_directory) {
-      fprintf(stderr, "Error: memory allocation failed for directory paths\n");
-      exit_code = 1;
-      goto cleanup;
-    }
     config->save_to_disk = true;
-
     config_parse_ssh_dest(config);
   } else if (positional_count == 1) {
     fprintf(stderr, "Error: missing destination argument\n");
@@ -427,82 +392,16 @@ int main(int argc, char* argv[]) {
     exit_code = 1;
     goto cleanup;
   } else {
-    if (!config->send_directory && env_source) {
+    if (!config->send_directory && env_source)
       config->send_directory = str_dup((char*)env_source);
-      if (!config->send_directory) {
+    if (!config->receive_root_directory && env_dest)
-        fprintf(stderr, "Error: memory allocation failed for source directory\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-    }
-    if (!config->receive_root_directory && env_dest) {
       config->receive_root_directory = str_dup((char*)env_dest);
-      if (!config->receive_root_directory) {
-        fprintf(stderr, "Error: memory allocation failed for destination directory\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-    }
   }
 
-  if (!config->send_directory || !config->receive_root_directory) {
+  if (!validate_config(config)) {
-    fprintf(stderr, "Error: source and destination directories are required\n");
-    print_usage();
     exit_code = 1;
     goto cleanup;
   }
-  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");
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  if (config->transport == TRANSPORT_SSH && config->use_sendfile) {
-    fprintf(stderr, "Error: -f/--sendfile is not supported with SSH transport\n");
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  if (config->use_incremental && config->use_chunk_serialization) {
-    fprintf(stderr, "Error: --incremental is not supported with -s (chunk serialization)\n");
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  if (config->use_incremental && !config->use_metadata) {
-    log_message(LOG_LEVEL_INFO, "Enabling metadata preservation for --incremental");
-    config->use_metadata = true;
-  }
-
-  if (config->use_delta && !config->use_incremental) {
-    fprintf(stderr, "Error: --delta requires --incremental\n");
-    exit_code = 1;
-    goto cleanup;
-  }
-  if (config->use_delta && config->use_chunk_serialization) {
-    fprintf(stderr, "Error: --delta cannot be combined with -s (chunk serialization)\n");
-    exit_code = 1;
-    goto cleanup;
-  }
-  if (config->use_delta && config->use_sendfile) {
-    fprintf(stderr, "Error: --delta cannot be combined with -f (sendfile)\n");
-    exit_code = 1;
-    goto cleanup;
-  }
-  if (config->use_delta && !config->use_metadata) {
-    log_message(LOG_LEVEL_INFO, "Enabling metadata preservation for --delta");
-    config->use_metadata = true;
-  }
-
-  if (config->use_tls) {
-    if (!config->tls_cert || !config->tls_key) {
-      fprintf(stderr, "Error: --tls requires --cert and --key\n");
-      exit_code = 1;
-      goto cleanup;
-    }
-    tls_global_init();
-  }
 
   tcp_set_timeouts(config->timeout, config->contimeout);
 

src/client/client_send.c

@@ -364,62 +364,86 @@ static int load_files_multithreaded(void* pipeline_context) {
   }
 }
 
-int send_files(Config* config) {
+static int run_dry_run(Config* config) {
-  if (config->dry_run) {
+  DirectoryScanner* scanner = directory_scanner_create(
-    DirectoryScanner* scanner = directory_scanner_create(
+      config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
-        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->exclude_count, config->include_patterns, config->include_count, config->max_size,
+      config->min_size, config->max_depth);
-        config->min_size, config->max_depth);
+  if (!scanner)
-    Chunk* chunk;
+    return -1;
-    int file_count = 0;
+  Chunk* chunk;
-    unsigned long long total_bytes = 0;
+  int file_count = 0;
-    printf("Dry run: files to be transferred\n");
+  unsigned long long total_bytes = 0;
-    while ((chunk = directory_scanner_next(scanner)) != NULL) {
+  printf("Dry run: files to be transferred\n");
-      for (int i = 0; i < chunk->element_count; i++) {
+  while ((chunk = directory_scanner_next(scanner)) != NULL) {
-        printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
+    for (int i = 0; i < chunk->element_count; i++) {
-        total_bytes += chunk->items[i]->data->size;
+      printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
-        file_count++;
+      total_bytes += chunk->items[i]->data->size;
-      }
+      file_count++;
-      chunk_destroy(chunk);
     }
-    directory_scanner_destroy(scanner);
+    chunk_destroy(chunk);
-    printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
-    return 0;
   }
+  directory_scanner_destroy(scanner);
+  printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
+  return 0;
+}
 
-  Client* client;
+static Client* connect_to_server(Config* config) {
   if (config->transport == TRANSPORT_SSH) {
     if (config->use_sendfile) {
       fprintf(stderr, "Error: -f/--sendfile is not supported with SSH transport\n");
-      return 1;
+      return NULL;
-    }
-    client =
-        client_connect_ssh(config->ssh_destination, config->ssh_port, config->fastsync_server_path);
-    if (!client)
-      return 1;
-  } else if (config->use_tls) {
-    client = client_create();
-    if (!client || !client_connect_tls(client, config->server_host, config->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;
     }
+    return client_connect_ssh(config->ssh_destination, config->ssh_port,
+                              config->fastsync_server_path);
+  }
+  Client* client = client_create();
+  if (!client)
+    return NULL;
+  bool ok;
+  if (config->use_tls) {
+    ok = client_connect_tls(client, config->server_host, config->server_port, config->tls_cert,
+                            config->tls_key, config->tls_ca);
   } else {
-    client = client_create();
+    ok = client_connect(client, config->server_host, config->server_port);
-    if (!client || !client_connect(client, config->server_host, config->server_port)) {
-      if (client)
-        client_delete(client);
-      fprintf(stderr, "Error: could not connect to server\n");
-      return 1;
-    }
   }
-  if (!config_send(client->file_descriptor, config)) {
+  if (!ok) {
-    client_disconnect(client);
     client_delete(client);
-    return 1;
+    fprintf(stderr, "Error: could not connect to server\n");
+    return NULL;
   }
+  return client;
+}
+
+static bool send_manifest(int fd, ArrayList* manifest) {
+  if (!send_status(fd, STATUS_MANIFEST))
+    return false;
+  if (!send_int(fd, manifest->size))
+    return false;
+  for (int i = 0; i < manifest->size; i++) {
+    if (!send_str(fd, (char*)manifest->items[i]))
+      return false;
+  }
+  return true;
+}
+
+static void print_progress(unsigned long long total_bytes, time_t start) {
+  double elapsed = difftime(time(NULL), start);
+  double rate = elapsed > 0 ? total_bytes / (1048576.0 * elapsed) : 0;
+  fprintf(stderr, "\rSent %.1f MB  (%.1f MB/s)  ", total_bytes / 1048576.0, rate);
+  fflush(stderr);
+}
+
+int send_files(Config* config) {
+  if (config->dry_run)
+    return run_dry_run(config);
+
+  Client* client = connect_to_server(config);
+  if (!client)
+    return 1;
+  if (!config_send(client->file_descriptor, config))
+    goto send_fail;
+
   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,
@@ -461,40 +485,26 @@ int send_files(Config* config) {
       time_t now = time(NULL);
       if (now - last_progress >= 1) {
         last_progress = now;
-        double elapsed = difftime(now, start);
+        print_progress(total_bytes, start);
-        double rate = elapsed > 0 ? total_bytes / (1048576.0 * elapsed) : 0;
-        fprintf(stderr, "\rSent %.1f MB  (%.1f MB/s)  ", total_bytes / 1048576.0, rate);
-        fflush(stderr);
       }
     }
     chunk_destroy(current_chunk);
   }
   if (config->use_delete) {
-    if (!send_status(client->file_descriptor, STATUS_MANIFEST)) {
+    if (!send_manifest(client->file_descriptor, manifest)) {
       array_list_delete(manifest);
       goto send_fail;
     }
-    if (!send_int(client->file_descriptor, manifest->size)) {
-      array_list_delete(manifest);
-      goto send_fail;
-    }
-    for (int i = 0; i < manifest->size; i++) {
-      if (!send_str(client->file_descriptor, (char*)manifest->items[i])) {
-        array_list_delete(manifest);
-        goto send_fail;
-      }
-    }
     array_list_delete(manifest);
   }
   if (!send_status(client->file_descriptor, STATUS_FINISHED))
     goto send_fail;
   Status s;
   int ok = receive_status(client->file_descriptor, &s) && s == STATUS_OK;
-  if (config->show_progress) {
+  if (config->show_progress)
-    double elapsed = difftime(time(NULL), start);
+    print_progress(total_bytes, start);
-    double rate = elapsed > 0 ? total_bytes / (1048576.0 * elapsed) : 0;
+  if (config->show_progress)
-    fprintf(stderr, "\rSent %.1f MB  (%.1f MB/s)  Done.\n", total_bytes / 1048576.0, rate);
+    fprintf(stderr, "Done.\n");
-  }
   directory_scanner_destroy(scanner);
   client_disconnect(client);
   client_delete(client);
@@ -508,27 +518,8 @@ send_fail:
 }
 
 int send_files_multithreaded(Config* config) {
-  if (config->dry_run) {
+  if (config->dry_run)
-    DirectoryScanner* scanner = directory_scanner_create(
+    return run_dry_run(config);
-        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, config->max_depth);
-    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);
-        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);
-    return 0;
-  }
 
   long pages = sysconf(_SC_AVPHYS_PAGES);
   long page_size = sysconf(_SC_PAGE_SIZE);

src/shared/config.c

@@ -8,57 +8,21 @@
 #include <stdlib.h>
 #include <string.h>
 
-Config* config_create(char* version, char* send_directory, char* receive_directory,
+Config* config_create(void) {
-                      bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
+  Config* config = calloc(1, sizeof(Config));
-                      bool use_compression, bool use_metadata, int compression_level,
-                      bool use_sendfile, unsigned long long chunk_size) {
-
-  Config* config = malloc(sizeof(Config));
   if (!config)
     return NULL;
-  config->version = version;
+  config->version = str_dup(PROTOCOL_VERSION);
-  config->send_directory = send_directory;
+  config->compression_level = 5;
-  config->receive_root_directory = receive_directory;
+  config->chunk_size = DEFAULT_CHUNK_SIZE;
-  config->save_to_disk = save_to_disk;
-  config->use_multithreading = use_multithreading;
-  config->use_chunk_serialization = use_chunk_serialization;
-  config->use_compression = use_compression;
-  config->use_metadata = use_metadata;
-  config->show_progress = false;
-  config->dry_run = false;
-  config->use_delete = false;
-  config->compression_level = compression_level;
-  config->use_sendfile = use_sendfile;
-  config->chunk_size = chunk_size > 0 ? chunk_size : DEFAULT_CHUNK_SIZE;
   config->ssh_port = 22;
-  config->transport = TRANSPORT_TCP;
-  config->ssh_destination = NULL;
-  config->fastsync_server_path = NULL;
-  config->exclude_patterns = NULL;
-  config->exclude_count = 0;
-  config->include_patterns = NULL;
-  config->include_count = 0;
-  config->max_size = 0;
-  config->min_size = 0;
-  config->use_incremental = false;
-  config->use_delta = false;
-  config->delta_block_size = DELTA_BLOCK_SIZE_DEFAULT;
-  config->delta_max_file_size = DELTA_MAX_FILE_SIZE;
-  config->use_tls = false;
-  config->tls_cert = NULL;
-  config->tls_key = NULL;
-  config->tls_ca = NULL;
-  config->server_host = str_dup("127.0.0.1");
   config->server_port = 8080;
+  config->server_host = str_dup("127.0.0.1");
   config->timeout = 30;
   config->contimeout = 10;
-  config->quiet = false;
-  config->backup = false;
-  config->backup_dir = NULL;
-  config->stats = false;
-  config->max_depth = 0;
-  config->log_file = NULL;
   config->queue_size = 100;
+  config->delta_block_size = DELTA_BLOCK_SIZE_DEFAULT;
+  config->delta_max_file_size = DELTA_MAX_FILE_SIZE;
   return config;
 }
 

src/shared/config.h

@@ -58,10 +58,7 @@ typedef struct Config {
 #define PROTOCOL_VERSION "1.3.0"
 #define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)
 
-Config* config_create(char* version, char* send_directory, char* receive_directory,
+Config* config_create(void);
-                      bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
-                      bool use_compression, bool use_metadata, int compression_level,
-                      bool use_sendfile, unsigned long long chunk_size);
 void config_delete(Config* config);
 bool config_send(int file_descriptor, const Config* config);
 Config* config_receive(int file_descriptor);

tests/test_config.c

@@ -7,9 +7,17 @@
 #include <stdlib.h>
 
 static void test_config_lifecycle() {
-  Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/dst"), true, true, false,
+  Config* cfg = config_create();
-                              false, false, 1, false, 0);
   EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("1.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/dst");
+  cfg->save_to_disk = true;
+  cfg->use_multithreading = true;
+  cfg->use_chunk_serialization = false;
+  cfg->use_compression = false;
+  cfg->compression_level = 1;
   EXPECT_EQ_STR(cfg->version, "1.0");
   EXPECT_EQ_STR(cfg->send_directory, "/src");
   EXPECT_EQ_STR(cfg->receive_root_directory, "/dst");
@@ -23,9 +31,14 @@ 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,
+  Config* cfg = config_create();
-                              false, false, false, false, 1, false, 0);
   EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("1.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("user@host:/dst");
+  cfg->save_to_disk = true;
+  cfg->compression_level = 1;
   EXPECT_EQ_INT(cfg->transport, TRANSPORT_TCP);
   EXPECT_NULL(cfg->ssh_destination);
   EXPECT_EQ_STR(cfg->receive_root_directory, "user@host:/dst");
@@ -38,8 +51,14 @@ 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,
+  Config* cfg = config_create();
-                              false, false, false, 1, false, 0);
+  EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("1.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/local/path");
+  cfg->save_to_disk = true;
+  cfg->compression_level = 1;
   config_parse_ssh_dest(cfg);
   EXPECT_EQ_INT(cfg->transport, TRANSPORT_TCP);
   EXPECT_NULL(cfg->ssh_destination);
@@ -48,8 +67,14 @@ 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,
+  Config* cfg = config_create();
-                              false, false, false, 1, false, 0);
+  EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("1.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("host:/remote");
+  cfg->save_to_disk = true;
+  cfg->compression_level = 1;
   config_parse_ssh_dest(cfg);
   EXPECT_EQ_INT(cfg->transport, TRANSPORT_SSH);
   EXPECT_EQ_STR(cfg->ssh_destination, "host:/remote");
@@ -58,8 +83,14 @@ 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,
+  Config* cfg = config_create();
-                              true, true, false, 1, false, 0);
+  free(cfg->version);
+  cfg->version = str_dup("2.0");
+  cfg->send_directory = str_dup("/src2");
+  cfg->receive_root_directory = str_dup("/dst2");
+  cfg->use_chunk_serialization = true;
+  cfg->use_compression = true;
+  cfg->compression_level = 1;
   Queue* q1 = queue_create(5, NULL);
   Queue* q2 = queue_create(15, NULL);
 
@@ -75,8 +106,16 @@ 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,
+  Config* cfg = config_create();
-                              true, false, 1, false, 0);
+  free(cfg->version);
+  cfg->version = str_dup("3.0");
+  cfg->send_directory = str_dup("/src3");
+  cfg->receive_root_directory = str_dup("/dst3");
+  cfg->save_to_disk = true;
+  cfg->use_multithreading = true;
+  cfg->use_chunk_serialization = true;
+  cfg->use_compression = true;
+  cfg->compression_level = 1;
   Queue* q = queue_create(20, NULL);
 
   PipelineContextReceiver* pcr = pipeline_context_receiver_create(cfg, q, 42);

tests/test_file.c

@@ -154,8 +154,9 @@ static void test_file_send_receive() {
   memcpy(file->data->data, content, len);
   file->data->size = len;
 
-  Config* cfg = config_create(str_dup(PROTOCOL_VERSION), str_dup("/tmp"), str_dup("/tmp"), false,
+  Config* cfg = config_create();
-                              false, false, false, false, 0, false, 0);
+  cfg->send_directory = str_dup("/tmp");
+  cfg->receive_root_directory = str_dup("/tmp");
 
   int p[2];
   EXPECT_EQ_INT(pipe(p), 0);

tests/test_file_sendfile.c

@@ -22,9 +22,10 @@ static void test_sendfile_basic() {
   /* Set the size so file_send_sendfile can report it */
   file->data->size = len;
 
-  Config* cfg = config_create(str_dup(PROTOCOL_VERSION), str_dup("/tmp"), str_dup("/tmp"), false,
+  Config* cfg = config_create();
-                              false, false, false, false, 0, false, 0);
   EXPECT_NOT_NULL(cfg);
+  cfg->send_directory = str_dup("/tmp");
+  cfg->receive_root_directory = str_dup("/tmp");
 
   int p[2];
   EXPECT_EQ_INT(pipe(p), 0);
@@ -80,9 +81,10 @@ static void test_sendfile_empty_file() {
   EXPECT_NOT_NULL(file);
   file->data->size = 0;
 
-  Config* cfg = config_create(str_dup(PROTOCOL_VERSION), str_dup("/tmp"), str_dup("/tmp"), false,
+  Config* cfg = config_create();
-                              false, false, false, false, 0, false, 0);
   EXPECT_NOT_NULL(cfg);
+  cfg->send_directory = str_dup("/tmp");
+  cfg->receive_root_directory = str_dup("/tmp");
 
   int p[2];
   EXPECT_EQ_INT(pipe(p), 0);
@@ -91,6 +93,7 @@ static void test_sendfile_empty_file() {
 
   pid_t pid = fork();
   if (pid == 0) {
+    /* Child: receive */
     close(p[1]);
     File* received = file_receive(cfg, p[0]);
     close(p[0]);
@@ -161,9 +164,12 @@ static void test_sendfile_compression_fallback() {
   file->data->size = (size_t)st.st_size;
   EXPECT_TRUE(file_load_data(file));
 
-  Config* cfg = config_create(str_dup(PROTOCOL_VERSION), str_dup("/tmp"), str_dup("/tmp"), false,
+  Config* cfg = config_create();
-                              false, false, true, false, 3, false, 0);
   EXPECT_NOT_NULL(cfg);
+  cfg->send_directory = str_dup("/tmp");
+  cfg->receive_root_directory = str_dup("/tmp");
+  cfg->use_compression = true;
+  cfg->compression_level = 3;
 
   int p[2];
   EXPECT_EQ_INT(pipe(p), 0);
@@ -172,6 +178,7 @@ static void test_sendfile_compression_fallback() {
 
   pid_t pid = fork();
   if (pid == 0) {
+    /* Child: receive */
     close(p[1]);
     File* received = file_receive(cfg, p[0]);
     close(p[0]);

tests/test_multiprocessing.c

@@ -8,9 +8,12 @@
 
 /* Test pipeline_context_sender_create/destroy with valid arguments */
 static void test_sender_create_destroy() {
-  Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/dst"), false, false, false,
+  Config* cfg = config_create();
-                              false, false, 0, false, 0);
   EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("1.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/dst");
 
   Queue* q_scanner = queue_create(5, NULL);
   EXPECT_NOT_NULL(q_scanner);
@@ -32,9 +35,14 @@ static void test_sender_create_destroy() {
 
 /* Test pipeline_context_receiver_create/destroy with valid arguments */
 static void test_receiver_create_destroy() {
-  Config* cfg = config_create(str_dup("2.0"), str_dup("/src"), str_dup("/dst"), true, true, false,
+  Config* cfg = config_create();
-                              false, false, 0, false, 0);
   EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("2.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/dst");
+  cfg->save_to_disk = true;
+  cfg->use_multithreading = true;
 
   Queue* q = queue_create(20, NULL);
   EXPECT_NOT_NULL(q);
@@ -51,9 +59,12 @@ static void test_receiver_create_destroy() {
 
 /* Test that create handles various queue capacities */
 static void test_sender_queue_capacities() {
-  Config* cfg = config_create(str_dup("3.0"), str_dup("/src"), str_dup("/dst"), false, false, false,
+  Config* cfg = config_create();
-                              false, false, 0, false, 0);
   EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("3.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/dst");
 
   /* Single-element queues */
   Queue* q1 = queue_create(1, NULL);
@@ -67,9 +78,12 @@ static void test_sender_queue_capacities() {
 
 /* Test that create handles zero-capacity queues */
 static void test_sender_zero_capacity() {
-  Config* cfg = config_create(str_dup("4.0"), str_dup("/src"), str_dup("/dst"), false, false, false,
+  Config* cfg = config_create();
-                              false, false, 0, false, 0);
   EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup("4.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/dst");
 
   Queue* q1 = queue_create(0, NULL);
   Queue* q2 = queue_create(0, NULL);
@@ -82,8 +96,11 @@ static void test_sender_zero_capacity() {
 
 /* Test receiver with zero file_descriptor */
 static void test_receiver_fd_zero() {
-  Config* cfg = config_create(str_dup("5.0"), str_dup("/src"), str_dup("/dst"), false, false, false,
+  Config* cfg = config_create();
-                              false, false, 0, false, 0);
+  free(cfg->version);
+  cfg->version = str_dup("5.0");
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/dst");
   Queue* q = queue_create(5, NULL);
   PipelineContextReceiver* ctx = pipeline_context_receiver_create(cfg, q, 0);
   EXPECT_NOT_NULL(ctx);