Revert "Merge pull request 'Merge all 5 batch PRs: security, CLI features, protocol, performance, tests/docs' (#143) from merge-all-v2 into main"

This reverts commit 29f4f8cde6, reversing
changes made to c6bf7bb84e.

tests/runner.c

@@ -47,12 +47,12 @@ int main() {
   RUN_TEST(test_file_sendfile);
   RUN_TEST(test_multiprocessing);
   RUN_TEST(test_log);
-  RUN_TEST(test_robustness);
-  RUN_TEST(test_stress);
-  RUN_TEST(test_property);
   RUN_TEST(test_transport_tcp);
   RUN_TEST(test_transport_ssh);
   RUN_TEST(test_transport_tls);
+  RUN_TEST(test_robustness);
+  RUN_TEST(test_stress);
+  RUN_TEST(test_property);
 
   printf("\n\033[1;36m=== TEST SUMMARY ===\033[0m\n");
   printf("Total Tests Run: %d\n", tests_run);

tests/test_file.c

@@ -69,7 +69,7 @@ static void test_file_save_to_disk() {
   memcpy(f->data->data, content, strlen(content));
   f->data->size = strlen(content);
 
-  EXPECT_TRUE(file_save_to_disk("test_save_tmp", f, NULL));
+  EXPECT_TRUE(file_save_to_disk("test_save_tmp", f));
 
   struct stat st;
   EXPECT_EQ_INT(stat("test_save_tmp/saved_file.txt", &st), 0);
@@ -217,6 +217,10 @@ static void test_file_send_no_path() {
   pid_t pid = fork();
   if (pid == 0) {
     close(p[1]);
+    // Read file type indicator
+    int file_type;
+    EXPECT_TRUE(receive_int(p[0], &file_type));
+    EXPECT_EQ_INT(file_type, (int)FILE_TYPE_REGULAR);
     Data* received = receive_data(p[0]);
     close(p[0]);
 

tests/test_file_sendfile.c

@@ -224,6 +224,10 @@ static void test_sendfile_no_path() {
   pid_t pid = fork();
   if (pid == 0) {
     close(p[1]);
+    /* When send_path is false, the sender still sends file_type + data */
+    int file_type;
+    EXPECT_TRUE(receive_int(p[0], &file_type));
+    EXPECT_EQ_INT(file_type, (int)FILE_TYPE_REGULAR);
     Data* received = receive_data(p[0]);
     close(p[0]);
 

tests/test_protocol.c

@@ -46,6 +46,7 @@ static void test_send_receive_str() {
 
   EXPECT_TRUE(send_str(0, ""));
 
+  /* cppcheck-suppress constVariablePointer */
   char* received = receive_str(0);
   EXPECT_NOT_NULL(received);
   EXPECT_EQ_STR(received, "");
@@ -63,6 +64,7 @@ static void test_send_receive_str_normal() {
 
   EXPECT_TRUE(send_str(0, "Hello, Protocol!"));
 
+  /* cppcheck-suppress constVariablePointer */
   char* received = receive_str(0);
   EXPECT_NOT_NULL(received);
   EXPECT_EQ_STR(received, "Hello, Protocol!");
@@ -78,6 +80,7 @@ static void test_send_receive_data() {
   io_set_fds(p[0], p[1]);
   io_set_bwlimit(0);
 
+  /* cppcheck-suppress constVariablePointer */
   unsigned char bin[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0xFF};
   void* buf = malloc(sizeof(bin));
   EXPECT_NOT_NULL(buf);
@@ -128,9 +131,9 @@ static void test_send_receive_status() {
   io_set_fds(p[0], p[1]);
   io_set_bwlimit(0);
 
-  Status statuses[] = {STATUS_OK,        STATUS_ERROR, STATUS_FINISHED,        STATUS_NEXT,
-                       STATUS_CHUNK,     STATUS_CHECK, STATUS_DELTA_SIGNATURE, STATUS_DELTA_DATA,
-                       STATUS_KEEPALIVE, STATUS_ABORT, STATUS_CHECK_BATCH};
+  /* cppcheck-suppress constVariablePointer */
+  Status statuses[] = {STATUS_OK,    STATUS_ERROR, STATUS_FINISHED,        STATUS_NEXT,
+                       STATUS_CHUNK, STATUS_CHECK, STATUS_DELTA_SIGNATURE, STATUS_DELTA_DATA};
   int count = sizeof(statuses) / sizeof(statuses[0]);
 
   for (int i = 0; i < count; i++) {
@@ -170,6 +173,23 @@ static void test_receive_str_truncated() {
   close(p[0]);
 }
 
+static void test_receive_str_oversized() {
+  int p[2];
+  EXPECT_EQ_INT(pipe(p), 0);
+  io_set_fds(p[0], p[1]);
+  io_set_bwlimit(0);
+
+  /* Send a size exceeding MAX_STRING_SIZE */
+  size_t huge = MAX_STRING_SIZE + 1;
+  EXPECT_TRUE(send_n_data(0, &huge, sizeof(size_t)));
+
+  const char* received = receive_str(0);
+  EXPECT_NULL(received);
+
+  close(p[0]);
+  close(p[1]);
+}
+
 void test_protocol() {
   test_send_receive_n_data();
   test_send_receive_n_data_zero();
@@ -180,4 +200,5 @@ void test_protocol() {
   test_send_receive_status();
   test_receive_n_data_truncated();
   test_receive_str_truncated();
+  test_receive_str_oversized();
 }

tests/test_scanner.c

@@ -19,7 +19,7 @@ static void test_scanner_single_file() {
   create_test_file(file1, content1);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -48,7 +48,7 @@ static void test_scanner_multiple_files() {
   create_test_file(file2, content2);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   const Chunk* chunk = directory_scanner_next(scanner);
@@ -88,7 +88,7 @@ static void test_scanner_subdirectory() {
   create_test_file(sub_file, content);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)root, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)root, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   int total_files = 0;
@@ -112,7 +112,7 @@ static void test_scanner_empty_directory() {
   EXPECT_EQ_INT(mkdir(dir, 0755), 0);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   const Chunk* chunk = directory_scanner_next(scanner);
@@ -136,7 +136,7 @@ static void test_scanner_exclude_pattern() {
 
   char* exclude[] = {"*.tmp"};
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, exclude, 1, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, exclude, 1, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -169,7 +169,7 @@ static void test_scanner_exclude_subdirectory() {
 
   char* exclude[] = {"*.tmp"};
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)root, false, 0, exclude, 1, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)root, false, 0, exclude, 1, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   int total = 0;
@@ -207,7 +207,7 @@ static void test_scanner_include_and_exclude() {
   char* exclude[] = {"*.bak"};
   char* include[] = {"*.txt", "*.log"};
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, exclude, 1, include, 2, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, exclude, 1, include, 2, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -244,7 +244,7 @@ static void test_scanner_max_size() {
 
   /* max_size = 10 — only files <= 10 bytes */
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 10, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 10, 0);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -272,7 +272,7 @@ static void test_scanner_min_size() {
 
   /* min_size = 1 — only files >= 1 byte */
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 1, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 1);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -302,7 +302,7 @@ static void test_scanner_size_range() {
 
   /* Only files between 3 and 20 bytes */
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 20, 3, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 20, 3);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -338,7 +338,7 @@ static void test_scanner_mixed_patterns() {
   char* exclude[] = {"*.bak"};
   char* include[] = {"*.txt"};
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, exclude, 1, include, 1, 10, 3, 0);
+      directory_scanner_create((char*)dir, false, 0, exclude, 1, include, 1, 10, 3);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -369,7 +369,7 @@ static void test_scanner_no_patterns() {
   create_test_file(f2, "second");
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);

tests/test_transport_ssh.c

@@ -1,14 +1,20 @@
 #include "test_transport_ssh.h"
-#include "test_utils.h"
 #include "transport_ssh.h"
+#include "test_utils.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
 
-static void test_ssh_connect_invalid_dest_no_colon() {
+/* Test client_connect_ssh with invalid destination (missing colon) */
+static void test_ssh_connect_invalid_dest() {
+  /* Missing colon — parse_remote_dest should fail and return NULL */
   /* cppcheck-suppress constVariablePointer */
   Client* client = client_connect_ssh("invalid-destination-no-colon", 22, NULL);
   EXPECT_NULL(client);
 }
 
-static void test_ssh_connect_invalid_dest_empty() {
+/* Test client_connect_ssh with empty destination */
+static void test_ssh_connect_empty_dest() {
   /* cppcheck-suppress constVariablePointer */
   Client* client = client_connect_ssh("", 22, NULL);
   EXPECT_NULL(client);
@@ -40,6 +46,8 @@ static void test_ssh_connect_unreachable() {
 }
 
 void test_transport_ssh() {
-  test_ssh_connect_invalid_dest_no_colon();
-  test_ssh_connect_invalid_dest_empty();
+  test_ssh_connect_invalid_dest();
+  test_ssh_connect_empty_dest();
+  test_ssh_connect_malformed();
+  test_ssh_connect_unreachable();
 }

tests/test_transport_tcp.c

@@ -1,43 +1,89 @@
 #include "test_transport_tcp.h"
-#include "test_utils.h"
 #include "transport_tcp.h"
+#include "test_utils.h"
+#include <stdlib.h>
 #include <unistd.h>
 
-static void test_server_create_ephemeral() {
-  Server* s = server_create(0);
-  EXPECT_NOT_NULL(s);
-  EXPECT_TRUE(s->file_descriptor >= 0);
-  EXPECT_EQ_INT(s->address.sin_family, AF_INET);
-  server_delete(&s);
-  EXPECT_NULL(s);
+/* Test client_create and client_delete lifecycle */
+static void test_client_create_delete() {
+  Client* client = client_create();
+  EXPECT_NOT_NULL(client);
+  EXPECT_EQ_INT(client->file_descriptor, -1);
+  EXPECT_EQ_INT(client->address.ss_family, AF_UNSPEC);
+  EXPECT_EQ_INT(client->ssh_child_pid, -1);
+  EXPECT_NULL(client->ssl);
+  EXPECT_NULL(client->ssl_ctx);
+
+  /* Delete should clean up without error */
+  client_delete(client);
 }
 
-static void test_server_delete_null() {
+/* Test client_delete with NULL (safety) */
+static void test_client_delete_null() {
+  client_delete(NULL);
+  EXPECT_TRUE(true);
+}
+
+/* Test server_create and server_delete lifecycle */
+static void test_server_create_delete() {
+  /* Use port 0 to let the OS assign a port */
+  Server* server = server_create(0);
+  EXPECT_NOT_NULL(server);
+  EXPECT_TRUE(server->file_descriptor >= 0);
+  EXPECT_TRUE(server->address.ss_family == AF_INET || server->address.ss_family == AF_INET6);
+  EXPECT_NULL(server->ssl_ctx);
+
+  /* Clean up */
+  server_delete(&server);
+  EXPECT_NULL(server);
+}
+
+/* Test server_delete with NULL pointer */
+static void test_server_delete_null_ptr() {
+  server_delete(NULL);
+  EXPECT_TRUE(true);
+}
+
+/* Test server_delete with NULL server */
+static void test_server_delete_null_server() {
   Server* s = NULL;
   server_delete(&s);
   EXPECT_NULL(s);
 }
 
-static void test_client_create() {
-  Client* c = client_create();
-  EXPECT_NOT_NULL(c);
-  EXPECT_TRUE(c->file_descriptor >= 0);
-  EXPECT_EQ_INT(c->address.sin_family, AF_INET);
-  EXPECT_EQ_INT(c->ssh_child_pid, -1);
-  EXPECT_NULL(c->ssl);
-  EXPECT_NULL(c->ssl_ctx);
-  client_disconnect(c);
-  client_delete(c);
+/* Test client_create can be called multiple times */
+static void test_client_create_multiple() {
+  Client* c1 = client_create();
+  Client* c2 = client_create();
+  EXPECT_NOT_NULL(c1);
+  EXPECT_NOT_NULL(c2);
+  EXPECT_EQ_INT(c1->file_descriptor, -1);
+  EXPECT_EQ_INT(c2->file_descriptor, -1);
+
+  client_delete(c1);
+  client_delete(c2);
 }
 
-static void test_client_delete_null() {
-  Client* c = NULL;
-  client_delete(c);
+/* Test client_disconnect on a fresh client (should close socket) */
+static void test_client_disconnect_fresh() {
+  Client* client = client_create();
+  EXPECT_NOT_NULL(client);
+
+  /* Disconnect should close the file descriptor */
+  client_disconnect(client);
+  /* The fd should now be invalid */
+  /* Verify by trying to use close() on it - should fail */
+  EXPECT_EQ_INT(close(client->file_descriptor), -1);
+
+  client_delete(client);
 }
 
 void test_transport_tcp() {
-  test_server_create_ephemeral();
-  test_server_delete_null();
-  test_client_create();
+  test_client_create_delete();
   test_client_delete_null();
+  test_server_create_delete();
+  test_server_delete_null_ptr();
+  test_server_delete_null_server();
+  test_client_create_multiple();
+  test_client_disconnect_fresh();
 }

tests/test_transport_tls.c

@@ -1,24 +1,81 @@
 #include "test_transport_tls.h"
-#include "test_utils.h"
-#include "transport_tcp.h"
 #include "transport_tls.h"
+#include "transport_tcp.h"
+#include "test_utils.h"
+#include <stdlib.h>
+#include <unistd.h>
 
+/* Test tls_global_init succeeds */
 static void test_tls_global_init() {
   bool ok = tls_global_init();
   EXPECT_TRUE(ok);
 }
 
-static void test_server_create_tls_without_certs() {
-  Server* s = server_create(0);
-  EXPECT_NOT_NULL(s);
-  bool ok = server_create_tls(s, NULL, NULL, NULL);
-  EXPECT_TRUE(ok);
-  EXPECT_NOT_NULL(s->ssl_ctx);
-  server_delete(&s);
-  EXPECT_NULL(s);
+/* Test tls_global_init can be called multiple times */
+static void test_tls_global_init_twice() {
+  bool ok1 = tls_global_init();
+  bool ok2 = tls_global_init();
+  EXPECT_TRUE(ok1);
+  EXPECT_TRUE(ok2);
+}
+
+/* Test client_connect_tls with bad certificate path.
+ * The function will create a socket, try to connect to localhost,
+ * fail to connect (since nothing is listening), and return false.
+ * We don't need a server to verify the error path. */
+static void test_tls_connect_bad_cert() {
+  /* First, init TLS globally */
+  tls_global_init();
+
+  Client* client = client_create();
+  EXPECT_NOT_NULL(client);
+
+  /* Attempt to connect to a non-existent server with bad cert paths.
+   * client_connect_tls will try to connect first, fail, and return false.
+   * Note: we use an invalid host to ensure connection failure,
+   * which exercises the error path before cert loading. */
+  bool ok = client_connect_tls(client, "127.0.0.1", 1, "/nonexistent/cert.pem",
+                               "/nonexistent/key.pem", "/nonexistent/ca.pem");
+  EXPECT_FALSE(ok);
+
+  client_delete(client);
+}
+
+/* Test client_connect_tls with NULL cert paths (should still attempt connection).
+ * Cert/key/ca being NULL is valid — the function will attempt to create an
+ * SSL context without client certificates. */
+static void test_tls_connect_null_paths() {
+  tls_global_init();
+
+  Client* client = client_create();
+  EXPECT_NOT_NULL(client);
+
+  /* Connect to invalid address — will fail at connect() step */
+  bool ok = client_connect_tls(client, "127.0.0.1", 1, NULL, NULL, NULL);
+  EXPECT_FALSE(ok);
+
+  client_delete(client);
+}
+
+/* Test server_create_tls with bad cert paths.
+ * The function should fail gracefully. */
+static void test_tls_server_bad_cert() {
+  tls_global_init();
+
+  Server* server = server_create(0);
+  EXPECT_NOT_NULL(server);
+
+  /* Load bad cert paths — should fail and return false */
+  bool ok = server_create_tls(server, "/nonexistent/cert.pem", "/nonexistent/key.pem", NULL);
+  EXPECT_FALSE(ok);
+
+  server_delete(&server);
 }
 
 void test_transport_tls() {
   test_tls_global_init();
-  test_server_create_tls_without_certs();
+  test_tls_global_init_twice();
+  test_tls_connect_bad_cert();
+  test_tls_connect_null_paths();
+  test_tls_server_bad_cert();
 }