From 2dd40d6a5b4d9ea4fb025b01c590fab94ab857c7 Mon Sep 17 00:00:00 2001 From: TapTap Date: Mon, 20 Jul 2026 19:27:13 +0200 Subject: [PATCH] =?UTF-8?q?fix:=20features=20and=20enhancements=20?= =?UTF-8?q?=E2=80=94=20issues=20#70,=20#36,=20#34,=20#33,=20#32,=20#57,=20?= =?UTF-8?q?#40,=20#37?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/client/client_cli.c | 3 + src/client/scanner.c | 77 +++++++++++++++- src/client/scanner.h | 6 ++ src/server/server.c | 42 ++++++++- src/shared/config.c | 86 ++++++++++++++++++ src/shared/config.h | 2 + src/shared/file.c | 167 +++++++++++++++++++++++++++++++--- src/shared/file.h | 4 + src/shared/transport_ssh.c | 2 +- src/shared/transport_tcp.c | 180 ++++++++++++++++++++++++++++++------- src/shared/transport_tcp.h | 7 +- src/shared/transport_tls.c | 33 ++++--- tests/test_file.c | 4 + 13 files changed, 553 insertions(+), 60 deletions(-) diff --git a/src/client/client_cli.c b/src/client/client_cli.c index de570b9..891afeb 100644 --- a/src/client/client_cli.c +++ b/src/client/client_cli.c @@ -55,6 +55,7 @@ static void print_usage(void) { printf(" --cert TLS certificate file (PEM)\n"); printf(" --key TLS private key file (PEM)\n"); printf(" --ca TLS CA certificate file (PEM)\n"); + printf(" --partial Keep partial files on interrupted transfer\n"); printf(" --help Show this help\n"); printf(" -V, --version Show version and exit\n"); } @@ -217,6 +218,8 @@ int main(int argc, char* argv[]) { } else if (strcmp(argv[i], "--ca") == 0 && i + 1 < argc) { free(config->tls_ca); config->tls_ca = str_dup(argv[++i]); + } else if (strcmp(argv[i], "--partial") == 0) { + config->partial = true; } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) { set_log_level(LOG_LEVEL_DEBUG); } else if (argv[i][0] == '-') { diff --git a/src/client/scanner.c b/src/client/scanner.c index 109ffa0..cdad303 100644 --- a/src/client/scanner.c +++ b/src/client/scanner.c @@ -16,6 +16,17 @@ DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metada int exclude_count, char** include_patterns, int include_count, unsigned long long max_size, unsigned long long min_size) { + return directory_scanner_create_full(root_directory, use_metadata, chunk_size, + exclude_patterns, exclude_count, + include_patterns, include_count, + max_size, min_size, true); +} + +DirectoryScanner* directory_scanner_create_full(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, bool follow_symlinks) { DirectoryScanner* scanner = malloc(sizeof(DirectoryScanner)); if (scanner == NULL) return NULL; @@ -79,6 +90,7 @@ DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metada scanner->include_count = include_count; scanner->max_size = max_size; scanner->min_size = min_size; + scanner->follow_symlinks = follow_symlinks; queue_enqueue(scanner->directories, str_dup(root_directory)); return scanner; } @@ -159,13 +171,76 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) { char* cur_path = path_cat(scanner->current_path, entry->d_name); struct stat stats; - if (stat(cur_path, &stats) != 0) { + // Use lstat to detect symlinks + if (lstat(cur_path, &stats) != 0) { free(cur_path); continue; } + // If follow_symlinks is enabled and this is a symlink, resolve it + if (scanner->follow_symlinks && S_ISLNK(stats.st_mode)) { + struct stat target_stats; + if (stat(cur_path, &target_stats) != 0) { + // Broken symlink, skip + free(cur_path); + continue; + } + stats = target_stats; + } + if (S_ISDIR(stats.st_mode)) { queue_enqueue(scanner->directories, (void*)cur_path); + } else if (S_ISLNK(stats.st_mode)) { + // Handle symlink (not following) + bool excluded = false; + for (int i = 0; i < scanner->exclude_count; i++) { + if (glob_match(scanner->exclude_patterns[i], entry->d_name)) { + excluded = true; + break; + } + } + if (excluded) { + free(cur_path); + continue; + } + + if (scanner->include_count > 0) { + bool included = false; + for (int i = 0; i < scanner->include_count; i++) { + if (glob_match(scanner->include_patterns[i], entry->d_name)) { + included = true; + break; + } + } + if (!included) { + free(cur_path); + continue; + } + } + + File* file = file_create(cur_path); + if (file == NULL) { + free(cur_path); + continue; + } + file->type = FILE_TYPE_SYMLINK; + // Read link target + char link_buf[4096]; + ssize_t link_len = readlink(cur_path, link_buf, sizeof(link_buf) - 1); + if (link_len >= 0) { + link_buf[link_len] = '\0'; + file->link_target = str_dup(link_buf); + } + file->data->size = 0; + if (scanner->use_metadata) + file->metadata = file_metadata_create(&stats); + array_list_add(chunk_data, file); + chunk_data_size += 1; // small size for symlinks + if (chunk_data_size > scanner->chunk_size) { + free(cur_path); + return chunk_data_to_chunk(chunk_data); + } + free(cur_path); } else { bool excluded = false; for (int i = 0; i < scanner->exclude_count; i++) { diff --git a/src/client/scanner.h b/src/client/scanner.h index 8202d61..166bc34 100644 --- a/src/client/scanner.h +++ b/src/client/scanner.h @@ -18,6 +18,7 @@ typedef struct { int include_count; unsigned long long max_size; unsigned long long min_size; + bool follow_symlinks; } DirectoryScanner; DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metadata, @@ -25,6 +26,11 @@ DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metada int exclude_count, char** include_patterns, int include_count, unsigned long long max_size, unsigned long long min_size); +DirectoryScanner* directory_scanner_create_full(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, bool follow_symlinks); Chunk* directory_scanner_next(DirectoryScanner* scanner); void directory_scanner_destroy(DirectoryScanner* scanner); diff --git a/src/server/server.c b/src/server/server.c index 2a902bb..8f61e34 100644 --- a/src/server/server.c +++ b/src/server/server.c @@ -11,11 +11,47 @@ #include "transport_tls.h" #include "unistd.h" #include "utils.h" +#include #include #include #include #include +// Check if a file path should be excluded based on config patterns +static bool is_excluded(const char* path, const Config* config) { + // Extract filename from path + char* path_dup = str_dup(path); + if (!path_dup) + return false; + char* fname = basename(path_dup); + + // Check exclude patterns + for (int i = 0; i < config->exclude_count; i++) { + if (glob_match(config->exclude_patterns[i], fname)) { + free(path_dup); + return true; + } + } + + // Check include patterns (if any, file must match at least one) + if (config->include_count > 0) { + bool included = false; + for (int i = 0; i < config->include_count; i++) { + if (glob_match(config->include_patterns[i], fname)) { + included = true; + break; + } + } + if (!included) { + free(path_dup); + return true; + } + } + + free(path_dup); + return false; +} + int receive_files(Config* config, int fd) { Status status; if (!receive_status(fd, &status)) @@ -29,7 +65,7 @@ int receive_files(Config* config, int fd) { goto next; if (file == NULL && !skipped) return -1; - if (config->save_to_disk) + if (config->save_to_disk && !is_excluded(file->path, config)) file_save_to_disk(config->receive_root_directory, file); file_destroy(file); } else if (status == STATUS_CHUNK) { @@ -39,7 +75,7 @@ int receive_files(Config* config, int fd) { return -1; } for (int i = 0; i < chunk->element_count; i++) { - if (config->save_to_disk) + if (config->save_to_disk && !is_excluded(chunk->items[i]->path, config)) file_save_to_disk(config->receive_root_directory, chunk->items[i]); } chunk_destroy(chunk); @@ -50,7 +86,7 @@ int receive_files(Config* config, int fd) { send_status(fd, STATUS_ERROR); return -1; } - if (config->save_to_disk) + if (config->save_to_disk && !is_excluded(file->path, config)) file_save_to_disk(config->receive_root_directory, file); file_destroy(file); } diff --git a/src/shared/config.c b/src/shared/config.c index 8ae4c5e..e4c7698 100644 --- a/src/shared/config.c +++ b/src/shared/config.c @@ -45,6 +45,8 @@ Config* config_create(char* version, char* send_directory, char* receive_directo config->tls_cert = NULL; config->tls_key = NULL; config->tls_ca = NULL; + config->follow_symlinks = false; + config->partial = false; config->server_host = str_dup("127.0.0.1"); config->server_port = 8080; return config; @@ -127,6 +129,26 @@ bool config_send(int file_descriptor, const Config* config) { return false; if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long))) return false; + if (!send_int(file_descriptor, config->exclude_count)) + return false; + for (int i = 0; i < config->exclude_count; i++) { + if (!send_str(file_descriptor, config->exclude_patterns[i])) + return false; + } + if (!send_int(file_descriptor, config->include_count)) + return false; + for (int i = 0; i < config->include_count; i++) { + if (!send_str(file_descriptor, config->include_patterns[i])) + return false; + } + if (!send_n_data(file_descriptor, &config->max_size, sizeof(config->max_size))) + return false; + if (!send_n_data(file_descriptor, &config->min_size, sizeof(config->min_size))) + return false; + if (!send_int(file_descriptor, config->follow_symlinks)) + return false; + if (!send_int(file_descriptor, config->partial)) + return false; Status status; if (!receive_status(file_descriptor, &status)) return false; @@ -221,6 +243,70 @@ Config* config_receive(int file_descriptor) { config->tls_cert = NULL; config->tls_key = NULL; config->tls_ca = NULL; + config->follow_symlinks = false; + config->partial = false; + + // Receive exclude patterns + int ec; + if (!receive_int(file_descriptor, &ec)) + goto error; + config->exclude_count = ec; + if (ec > 0) { + config->exclude_patterns = malloc((size_t)ec * sizeof(char*)); + if (!config->exclude_patterns) { + config->exclude_count = 0; + goto error; + } + for (int i = 0; i < ec; i++) { + config->exclude_patterns[i] = receive_str(file_descriptor); + if (!config->exclude_patterns[i]) { + for (int j = 0; j < i; j++) + free(config->exclude_patterns[j]); + free(config->exclude_patterns); + config->exclude_patterns = NULL; + config->exclude_count = 0; + goto error; + } + } + } + + // Receive include patterns + int ic; + if (!receive_int(file_descriptor, &ic)) + goto error; + config->include_count = ic; + if (ic > 0) { + config->include_patterns = malloc((size_t)ic * sizeof(char*)); + if (!config->include_patterns) { + config->include_count = 0; + goto error; + } + for (int i = 0; i < ic; i++) { + config->include_patterns[i] = receive_str(file_descriptor); + if (!config->include_patterns[i]) { + for (int j = 0; j < i; j++) + free(config->include_patterns[j]); + free(config->include_patterns); + config->include_patterns = NULL; + config->include_count = 0; + goto error; + } + } + } + + if (!receive_n_data(file_descriptor, &config->max_size, sizeof(config->max_size))) + goto error; + if (!receive_n_data(file_descriptor, &config->min_size, sizeof(config->min_size))) + goto error; + int tmp_follow; + if (!receive_int(file_descriptor, &tmp_follow)) + goto error; + config->follow_symlinks = tmp_follow; + int tmp_partial; + if (!receive_int(file_descriptor, &tmp_partial)) + goto error; + config->partial = tmp_partial; + config->server_host = str_dup("127.0.0.1"); config->server_port = 8080; if (!send_status(file_descriptor, STATUS_OK)) diff --git a/src/shared/config.h b/src/shared/config.h index 183f60c..e6a525d 100644 --- a/src/shared/config.h +++ b/src/shared/config.h @@ -40,6 +40,8 @@ typedef struct Config { char* tls_cert; char* tls_key; char* tls_ca; + bool follow_symlinks; + bool partial; } Config; #define PROTOCOL_VERSION "1.3.0" diff --git a/src/shared/file.c b/src/shared/file.c index 443330e..a86b6c6 100644 --- a/src/shared/file.c +++ b/src/shared/file.c @@ -20,6 +20,9 @@ #include "protocol.h" #include "utils.h" +#define STREAM_THRESHOLD (64ULL * 1024 * 1024) /* 64 MB */ +#define STREAM_CHUNK_SIZE (1ULL * 1024 * 1024) /* 1 MB */ + File* file_create(const char* path) { File* file = (File*)malloc(sizeof(File)); if (file == NULL) { @@ -42,6 +45,8 @@ File* file_create(const char* path) { return NULL; } file->metadata = NULL; + file->type = FILE_TYPE_REGULAR; + file->link_target = NULL; return file; } @@ -55,6 +60,8 @@ void file_destroy(void* item) { file->metadata = NULL; free(file->path); file->path = NULL; + free(file->link_target); + file->link_target = NULL; free(file); } @@ -83,6 +90,14 @@ void file_metadata_destroy(void* metadata) { bool file_load_data(File* file) { if (file == NULL) return false; + // Symlinks have no data to load + if (file->type == FILE_TYPE_SYMLINK) + return true; + // For streaming files, just record the size, don't load into memory + if (file->data->size > STREAM_THRESHOLD) { + // Don't allocate; streaming will read directly from disk + return true; + } if (file->data->data == NULL) { file->data->data = malloc(file->data->size); if (file->data->data == NULL) { @@ -98,10 +113,69 @@ bool file_load_data(File* file) { return true; } +// Stream file content in chunks without loading entire file into RAM +static bool file_send_streaming(File* file, int file_descriptor) { + unsigned long long total_size = file->data->size; + // Send total size prefix (same wire format as send_data) + if (!send_n_data(file_descriptor, &total_size, sizeof(total_size))) + return false; + + FILE* fp = fopen(file->path, "rb"); + if (!fp) { + perror("Could not open file for streaming"); + return false; + } + + char buf[STREAM_CHUNK_SIZE]; + unsigned long long remaining = total_size; + while (remaining > 0) { + size_t to_read = (size_t)((remaining < STREAM_CHUNK_SIZE) ? remaining : STREAM_CHUNK_SIZE); + size_t nread = fread(buf, 1, to_read, fp); + if (nread != to_read) { + if (ferror(fp)) { + perror("Read error during streaming"); + } + fclose(fp); + return false; + } + if (!send_n_data(file_descriptor, buf, nread)) { + fclose(fp); + return false; + } + remaining -= (unsigned long long)nread; + } + fclose(fp); + return true; +} + bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata, int compression_level, 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; + + // Send file type indicator so receiver can distinguish regular from symlink + int ft = (int)file->type; + if (!send_int(file_descriptor, ft)) + return false; + + if (file->type == FILE_TYPE_SYMLINK) { + // Send link target, then zero-length data + if (!send_str(file_descriptor, file->link_target ? file->link_target : "")) + return false; + Data empty = {NULL, 0}; + return send_data(file_descriptor, &empty); + } + const Data* data_to_send = file->data; Data* compressed_data = NULL; + + // Streaming mode: for large files without compression, stream from disk + if (file->data->size > STREAM_THRESHOLD && compression_level == 0) { + return file_send_streaming(file, file_descriptor); + } + if (compression_level > 0) { compressed_data = data_compress(file->data, compression_level); if (compressed_data == NULL) { @@ -110,14 +184,6 @@ bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata, } data_to_send = compressed_data; } - if (send_path && !send_str(file_descriptor, file->path)) { - data_destroy(compressed_data); - return false; - } - if (use_metadata && !metadata_send(file_descriptor, file->metadata)) { - data_destroy(compressed_data); - return false; - } if (!send_data(file_descriptor, data_to_send)) { data_destroy(compressed_data); return false; @@ -127,6 +193,18 @@ bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata, } bool file_save_to_disk(const char* root_directory, File* file) { + if (file->type == FILE_TYPE_SYMLINK && file->link_target) { + char* disk_path = path_cat((char*)root_directory, file->path); + if (disk_path == NULL) + return false; + unlink(disk_path); + bool ok = (symlink(file->link_target, disk_path) == 0); + if (ok && file->metadata) + file_restore_metadata(disk_path, file->metadata); + free(disk_path); + return ok; + } + char* disk_path = path_cat((char*)root_directory, file->path); if (disk_path == NULL) return false; @@ -349,6 +427,18 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) { bool has_old_file = (full_path && stat(full_path, &st) == 0); unsigned long long old_size = has_old_file ? (unsigned long long)st.st_size : 0; + // Check for partial file if enabled + if (config->partial && !has_old_file && full_path) { + char* partial_path = malloc(strlen(full_path) + 20); + if (partial_path) { + sprintf(partial_path, "%s.fastsync-partial", full_path); + has_old_file = (stat(partial_path, &st) == 0); + if (has_old_file) + old_size = (unsigned long long)st.st_size; + free(partial_path); + } + } + bool match = has_old_file && (unsigned long long)st.st_size == check_size && (long long)st.st_mtime == check_mtime; @@ -397,6 +487,26 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) { if (!receive_and_assign_metadata(fd, config, file)) return NULL; + // Read file type indicator + int file_type; + if (!receive_int(fd, &file_type)) { + file_destroy(file); + send_status(fd, STATUS_ERROR); + return NULL; + } + file->type = (FileType)file_type; + + if (file->type == FILE_TYPE_SYMLINK) { + char* link_target = receive_str(fd); + if (link_target) { + file->link_target = link_target; + } + Data* empty_data = receive_data(fd); + if (empty_data) + data_destroy(empty_data); + return file; + } + Data* file_data = receive_and_decompress(fd, config); if (file_data == NULL) { file_destroy(file); @@ -447,13 +557,14 @@ done: bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int compression_level, bool send_path) { + // Handle symlinks + if (file->type == FILE_TYPE_SYMLINK) { + return file_send_single_calls(file, file_descriptor, use_metadata, compression_level, + send_path); + } + // sendfile is incompatible with compression (kernel zero-copy). // If compression is requested, fall back to the regular send path. - // NOTE: This is a safety net only — callers must ensure compression_level == 0 - // before calling file_send_sendfile. The fallback to file_send_single_calls - // preserves the send_path contract, but callers should not rely on it for - // correctness (the --sendfile flag is validated to be mutually exclusive with - // -c/--compress at the CLI layer). if (compression_level > 0) return file_send_single_calls(file, file_descriptor, use_metadata, compression_level, send_path); @@ -463,6 +574,11 @@ bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int if (use_metadata && !metadata_send(file_descriptor, file->metadata)) return false; + // Send file type indicator + int ft = (int)file->type; + if (!send_int(file_descriptor, ft)) + return false; + int fd = open(file->path, O_RDONLY); if (fd == -1) { perror("Could not open file for sendfile"); @@ -505,6 +621,30 @@ File* file_receive(const Config* config, int file_descriptor) { return NULL; } } + + // Receive file type indicator + int file_type; + if (!receive_int(file_descriptor, &file_type)) { + file_destroy(file); + return NULL; + } + file->type = (FileType)file_type; + + if (file->type == FILE_TYPE_SYMLINK) { + char* link_target = receive_str(file_descriptor); + if (link_target == NULL) { + file_destroy(file); + return NULL; + } + file->link_target = link_target; + // Receive and discard zero-length data + Data* empty_data = receive_data(file_descriptor); + if (empty_data) + data_destroy(empty_data); + return file; + } + + // Regular file - receive data Data* file_data = receive_data(file_descriptor); if (file_data == NULL) { file_destroy(file); @@ -519,6 +659,7 @@ File* file_receive(const Config* config, int file_descriptor) { } file_data = file_data_uncompressed; } + data_destroy(file->data); file->data = file_data; return file; diff --git a/src/shared/file.h b/src/shared/file.h index f6acac2..f5193f9 100644 --- a/src/shared/file.h +++ b/src/shared/file.h @@ -6,6 +6,8 @@ #include #include +typedef enum { FILE_TYPE_REGULAR, FILE_TYPE_SYMLINK, FILE_TYPE_DIR } FileType; + typedef struct { mode_t mode; uid_t uid; @@ -18,6 +20,8 @@ typedef struct { char* path; Data* data; FileMetadata* metadata; + FileType type; + char* link_target; } File; File* file_create(const char* path); diff --git a/src/shared/transport_ssh.c b/src/shared/transport_ssh.c index 4ff2bb8..1d992b5 100644 --- a/src/shared/transport_ssh.c +++ b/src/shared/transport_ssh.c @@ -186,7 +186,7 @@ Client* client_connect_ssh(const char* destination, int port) { return NULL; } client->file_descriptor = sv[0]; - client->address.sin_family = AF_UNIX; + client->address.ss_family = AF_UNIX; client->address_length = 0; client->ssh_child_pid = pid; client->ssl = NULL; diff --git a/src/shared/transport_tcp.c b/src/shared/transport_tcp.c index c06278b..e53a854 100644 --- a/src/shared/transport_tcp.c +++ b/src/shared/transport_tcp.c @@ -2,29 +2,64 @@ #include "log.h" #include "protocol.h" #include +#include #include #include #include #include #include #include +#include #include #include +bool set_socket_timeouts(int fd) { + struct timeval tv; + tv.tv_sec = 30; + tv.tv_usec = 0; + + int keepalive = 1; + if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive)) < 0) { + perror("Could not set SO_KEEPALIVE"); + return false; + } + if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) { + perror("Could not set SO_RCVTIMEO"); + return false; + } + if (setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) { + perror("Could not set SO_SNDTIMEO"); + return false; + } + return true; +} + Server* server_create(int port) { Server* server = (Server*)malloc(sizeof(Server)); if (server == NULL) { perror("Could not allocate space for Server"); return NULL; } + memset(&server->address, 0, sizeof(server->address)); - int file_descriptor = socket(AF_INET, SOCK_STREAM, 0); - if (file_descriptor < 0) { + // Try IPv6 first, fall back to IPv4 + int fd = socket(AF_INET6, SOCK_STREAM, 0); + if (fd < 0) { + fd = socket(AF_INET, SOCK_STREAM, 0); + } + if (fd < 0) { perror("Could not create Socket!"); free(server); return NULL; } - server->file_descriptor = file_descriptor; + + if (!set_socket_timeouts(fd)) { + close(fd); + free(server); + return NULL; + } + + server->file_descriptor = fd; int opt = 1; if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) { perror("Error setting a socket option!"); @@ -33,18 +68,63 @@ Server* server_create(int port) { return NULL; } - server->address.sin_family = AF_INET; - server->address.sin_addr.s_addr = INADDR_ANY; - server->address.sin_port = htons(port); - server->address_length = sizeof(server->address); - server->ssl_ctx = NULL; + // Determine address family from the actual socket + struct sockaddr_storage* addr = &server->address; + socklen_t addr_len = sizeof(*addr); + if (getsockname(fd, (struct sockaddr*)addr, &addr_len) == 0) { + // Use the family of the socket we actually created + } + + struct sockaddr_in* addr4 = (struct sockaddr_in*)addr; + struct sockaddr_in6* addr6 = (struct sockaddr_in6*)addr; + + if (addr->ss_family == AF_INET6) { + addr6->sin6_family = AF_INET6; + addr6->sin6_addr = in6addr_any; + addr6->sin6_port = htons(port); + server->address_length = sizeof(struct sockaddr_in6); + } else { + addr4->sin_family = AF_INET; + addr4->sin_addr.s_addr = INADDR_ANY; + addr4->sin_port = htons(port); + server->address_length = sizeof(struct sockaddr_in); + } if (bind(server->file_descriptor, (struct sockaddr*)&server->address, server->address_length) < 0) { - perror("Could not bind server"); - close(server->file_descriptor); - free(server); - return NULL; + // If IPv6 bind failed (maybe no IPv6), try IPv4 + if (addr->ss_family == AF_INET6) { + close(fd); + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) { + perror("Could not create IPv4 Socket!"); + free(server); + return NULL; + } + if (!set_socket_timeouts(fd)) { + close(fd); + free(server); + return NULL; + } + server->file_descriptor = fd; + setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); + memset(addr, 0, sizeof(*addr)); + addr4->sin_family = AF_INET; + addr4->sin_addr.s_addr = INADDR_ANY; + addr4->sin_port = htons(port); + server->address_length = sizeof(struct sockaddr_in); + if (bind(server->file_descriptor, (struct sockaddr*)addr, server->address_length) < 0) { + perror("Could not bind server"); + close(server->file_descriptor); + free(server); + return NULL; + } + } else { + perror("Could not bind server"); + close(server->file_descriptor); + free(server); + return NULL; + } } return server; @@ -70,13 +150,14 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil } signal(SIGCHLD, SIG_IGN); while (1) { - struct sockaddr_in client_addr; + struct sockaddr_storage client_addr; socklen_t client_len = sizeof(client_addr); int fd = accept(server->file_descriptor, (struct sockaddr*)&client_addr, &client_len); if (fd < 0) { perror("Could not accept the connection"); continue; } + set_socket_timeouts(fd); log_message(LOG_LEVEL_INFO, "%s", log_fmt); pid_t pid = fork(); if (pid == 0) { @@ -98,7 +179,11 @@ static void plain_child_fn(int fd, void* ctx) { } 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 sockaddr_in* addr4 = (struct sockaddr_in*)&server->address; + int port = (server->address.ss_family == AF_INET6) + ? ntohs(((struct sockaddr_in6*)&server->address)->sin6_port) + : ntohs(addr4->sin_port); + log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d", port); struct plain_ctx ctx = {handler}; accept_loop(server, plain_child_fn, &ctx, "Received Connection"); return true; @@ -106,25 +191,23 @@ 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) { - log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d", ntohs(server->address.sin_port)); + struct sockaddr_in* addr4 = (struct sockaddr_in*)&server->address; + int port = (server->address.ss_family == AF_INET6) + ? ntohs(((struct sockaddr_in6*)&server->address)->sin6_port) + : ntohs(addr4->sin_port); + log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d", port); accept_loop(server, child_fn, child_ctx, log_fmt); } 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)); if (client == NULL) { - close(file_descriptor); return NULL; } - client->file_descriptor = file_descriptor; - client->address.sin_family = AF_INET; + memset(&client->address, 0, sizeof(client->address)); + client->address.ss_family = AF_UNSPEC; client->address_length = sizeof(client->address); + client->file_descriptor = -1; client->ssh_child_pid = -1; client->ssl = NULL; client->ssl_ctx = NULL; @@ -132,18 +215,52 @@ Client* client_create() { } bool client_connect(Client* client, char* host, int port) { - client->address.sin_port = htons(port); + struct addrinfo hints, *res, *rp; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; - if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) { - perror("Could not convert host address!"); + char port_str[16]; + snprintf(port_str, sizeof(port_str), "%d", port); + + int gai_err = getaddrinfo(host, port_str, &hints, &res); + if (gai_err != 0) { + fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(gai_err)); return false; } - if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) < - 0) { + // Try IPv6 first, then IPv4 + int fd = -1; + for (rp = res; rp != NULL; rp = rp->ai_next) { + fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + if (fd < 0) + continue; + if (!set_socket_timeouts(fd)) { + close(fd); + fd = -1; + continue; + } + if (connect(fd, rp->ai_addr, rp->ai_addrlen) == 0) + break; + close(fd); + fd = -1; + } + + if (fd < 0) { perror("Could not connect to Server!"); + freeaddrinfo(res); return false; } + + // Save the connected address + memcpy(&client->address, rp->ai_addr, rp->ai_addrlen); + client->address_length = rp->ai_addrlen; + freeaddrinfo(res); + + // Close old fd if any and set new one + if (client->file_descriptor >= 0) + close(client->file_descriptor); + client->file_descriptor = fd; return true; } @@ -154,7 +271,10 @@ void client_disconnect(Client* client) { client->ssl = NULL; io_set_ssl(NULL); } - close(client->file_descriptor); + if (client->file_descriptor >= 0) { + close(client->file_descriptor); + client->file_descriptor = -1; + } if (client->ssh_child_pid > 0) { int status; waitpid(client->ssh_child_pid, &status, 0); diff --git a/src/shared/transport_tcp.h b/src/shared/transport_tcp.h index 0c4b7da..45059ba 100644 --- a/src/shared/transport_tcp.h +++ b/src/shared/transport_tcp.h @@ -1,19 +1,21 @@ #ifndef TRANSPORT_TCP_H #define TRANSPORT_TCP_H +#include #include #include +#include #include typedef struct Server { - struct sockaddr_in address; + struct sockaddr_storage address; unsigned int address_length; int file_descriptor; void* ssl_ctx; } Server; typedef struct Client { - struct sockaddr_in address; + struct sockaddr_storage address; unsigned int address_length; int file_descriptor; pid_t ssh_child_pid; @@ -30,5 +32,6 @@ Client* client_create(); bool client_connect(Client* client, char* host, int port); void client_disconnect(Client* client); void client_delete(Client* client); +bool set_socket_timeouts(int fd); #endif diff --git a/src/shared/transport_tls.c b/src/shared/transport_tls.c index 4ce19a4..ae1eddd 100644 --- a/src/shared/transport_tls.c +++ b/src/shared/transport_tls.c @@ -5,6 +5,8 @@ #include #include #include +#include +#include #include #include #include @@ -32,7 +34,7 @@ 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 char* ca_path) { const SSL_METHOD* method = is_server ? TLS_server_method() : TLS_client_method(); SSL_CTX* ctx = SSL_CTX_new(method); if (!ctx) { @@ -72,6 +74,12 @@ static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key } SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); SSL_CTX_set_verify_depth(ctx, 4); + } else { + if (!is_server) { + log_message(LOG_LEVEL_WARNING, + "No CA path provided — TLS server certificate will not be verified"); + } + SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL); } return ctx; @@ -84,6 +92,7 @@ static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) { return NULL; } SSL_set_fd(ssl, fd); + int ret; if (is_server) ret = SSL_accept(ssl); @@ -96,6 +105,17 @@ static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) { SSL_free(ssl); return NULL; } + + // In client mode, check verification result if peer verification was requested + if (!is_server) { + long verify_result = SSL_get_verify_result(ssl); + if (verify_result != X509_V_OK) { + log_message(LOG_LEVEL_ERROR, "TLS certificate verification failed: %ld", verify_result); + SSL_free(ssl); + return NULL; + } + } + return ssl; } @@ -133,16 +153,9 @@ 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) { - client->address.sin_port = htons(port); - if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) { - perror("Could not convert host address!"); + // Use the common TCP connection logic (with IPv6 support) + if (!client_connect(client, host, port)) return false; - } - 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) diff --git a/tests/test_file.c b/tests/test_file.c index 1a65a05..d15adbc 100644 --- a/tests/test_file.c +++ b/tests/test_file.c @@ -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]); -- 2.52.0