TapTap/FastSync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: reformat codebase and fix const-correctness for CI lint
CI / lint (push) Failing after 16s
Details
CI / build-and-test (push) Has been skipped
Details
CI / sanitizers (address) (push) Has been skipped
Details
CI / sanitizers (thread) (push) Has been skipped
Details
CI / lint (pull_request) Failing after 44s
Details
CI / build-and-test (pull_request) Has been skipped
Details
CI / sanitizers (address) (pull_request) Has been skipped
Details
CI / sanitizers (thread) (pull_request) Has been skipped
Details

Browse Source 
- 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
This commit is contained in:
TapTap
2026-07-19 15:57:31 +02:00
parent 02266710fb
commit 23b1d6660c
44 changed files with 1053 additions and 923 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/client/client_cli.c
+19 -18
View File
@@ -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
+115 -110
View File
@@ -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
+4 -4
View File
@@ -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
+18 -14
View File
@@ -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
+12 -8
View File
@@ -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
src/server/server.c
+21 -18
View File
@@ -16,21 +16,24 @@
#include <stdlib.h>
#include <string.h>
int receive_files(Config *config, int fd) {
int receive_files(Config* config, int fd) {
Status status;
if (!receive_status(fd, &status)) return -1;
if (!receive_status(fd, &status))
return -1;
while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
if (status == STATUS_CHECK) {
bool skipped;
File *file = receive_incremental_check(fd, config, &skipped);
if (skipped) goto next;
if (file == NULL && !skipped) return -1;
File* file = receive_incremental_check(fd, config, &skipped);
if (skipped)
goto next;
if (file == NULL && !skipped)
return -1;
if (config->save_to_disk)
file_save_to_disk(config->receive_root_directory, file);
file_destroy(file);
} else if (status == STATUS_CHUNK) {
Chunk *chunk = receive_chunk_data(fd, config);
Chunk* chunk = receive_chunk_data(fd, config);
if (chunk == NULL) {
send_status(fd, STATUS_ERROR);
return -1;
@@ -41,7 +44,7 @@ int receive_files(Config *config, int fd) {
}
chunk_destroy(chunk);
} else {
File *file = file_receive(config, fd);
File* file = file_receive(config, fd);
if (file == NULL) {
log_message(LOG_LEVEL_ERROR, "Failed to receive file");
send_status(fd, STATUS_ERROR);
@@ -59,7 +62,8 @@ int receive_files(Config *config, int fd) {
}
if (status == STATUS_MANIFEST) {
if (receive_manifest(fd, config, &status) != 0) return -1;
if (receive_manifest(fd, config, &status) != 0)
return -1;
}
if (status != STATUS_FINISHED) {
log_message(LOG_LEVEL_ERROR, "Did not receive FINISHED Status");
@@ -71,21 +75,20 @@ int receive_files(Config *config, int fd) {
}
void handler(int file_descriptor) {
Config *config = config_receive(file_descriptor);
Config* config = config_receive(file_descriptor);
if (config == NULL) {
log_message(LOG_LEVEL_ERROR, "Failed to receive config");
close(file_descriptor);
return;
}
if (config->use_multithreading) {
Queue *q = queue_create(100, file_destroy);
Queue* q = queue_create(100, file_destroy);
if (q == NULL) {
config_delete(config);
close(file_descriptor);
return;
}
PipelineContextReceiver *context = pipeline_context_receiver_create(
config, q, file_descriptor);
PipelineContextReceiver* context = pipeline_context_receiver_create(config, q, file_descriptor);
if (context == NULL) {
queue_destroy(q);
config_delete(config);
@@ -109,7 +112,7 @@ void handler(int file_descriptor) {
close(file_descriptor);
}
static Server *g_server = NULL;
static Server* g_server = NULL;
static void cleanup(int sig) {
(void)sig;
@@ -134,11 +137,11 @@ static void print_server_usage(void) {
printf(" --help Show this help\n");
}
int main(int argc, char *argv[]) {
int main(int argc, char* argv[]) {
bool use_tls = false;
char *tls_cert = NULL;
char *tls_key = NULL;
char *tls_ca = NULL;
char* tls_cert = NULL;
char* tls_key = NULL;
char* tls_ca = NULL;
int port = 8080;
signal(SIGPIPE, SIG_IGN);
@@ -161,7 +164,7 @@ int main(int argc, char *argv[]) {
} else if (strcmp(argv[i], "--ca") == 0 && i + 1 < argc) {
tls_ca = argv[++i];
} else if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
char *end;
char* end;
long p = strtol(argv[++i], &end, 10);
if (*end || p <= 0 || p > 65535) {
fprintf(stderr, "Error: invalid port '%s' (must be 1-65535)\n", argv[i]);
src/shared/array_list.c
+14 -12
View File
@@ -3,14 +3,14 @@
#include <stdlib.h>
#include <string.h>
ArrayList *array_list_create(void (*item_destroyer)(void *item)) {
ArrayList *list = (ArrayList *)malloc(sizeof(ArrayList));
ArrayList* array_list_create(void (*item_destroyer)(void* item)) {
ArrayList* list = (ArrayList*)malloc(sizeof(ArrayList));
if (list == NULL) {
perror("ERROR: Could not allocate memory for array list struct");
return NULL;
}
list->items = malloc(INITIAL_ARRAY_SIZE * sizeof(void *));
list->items = malloc(INITIAL_ARRAY_SIZE * sizeof(void*));
if (list->items == NULL) {
free(list);
return NULL;
@@ -21,7 +21,7 @@ ArrayList *array_list_create(void (*item_destroyer)(void *item)) {
return list;
}
void array_list_delete(ArrayList *array_list) {
void array_list_delete(ArrayList* array_list) {
if (array_list == NULL)
return;
if (array_list->item_destroyer != NULL) {
@@ -34,12 +34,13 @@ void array_list_delete(ArrayList *array_list) {
free(array_list);
}
bool array_list_extend(ArrayList *array_list) {
if (array_list == NULL) return false;
bool array_list_extend(ArrayList* array_list) {
if (array_list == NULL)
return false;
int new_capacity = array_list->capacity * 2;
if (new_capacity == 0)
new_capacity = INITIAL_ARRAY_SIZE;
void *new_items = realloc(array_list->items, new_capacity * sizeof(void *));
void* new_items = realloc(array_list->items, new_capacity * sizeof(void*));
if (new_items == NULL) {
perror("ERROR: Could not reallocate memory for array list items");
return false;
@@ -49,8 +50,9 @@ bool array_list_extend(ArrayList *array_list) {
return true;
}
bool array_list_add(ArrayList *array_list, void *item) {
if (array_list == NULL) return false;
bool array_list_add(ArrayList* array_list, void* item) {
if (array_list == NULL)
return false;
if (array_list->capacity == array_list->size) {
if (!array_list_extend(array_list))
return false;
@@ -60,15 +62,15 @@ bool array_list_add(ArrayList *array_list, void *item) {
return true;
}
void **array_list_to_array(ArrayList *array_list) {
void** array_list_to_array(const ArrayList* array_list) {
if (array_list == NULL) {
return NULL;
}
void **array = malloc(array_list->size * sizeof(void *));
void** array = malloc(array_list->size * sizeof(void*));
if (array == NULL) {
perror("Could not malloc space for array from array list!");
return NULL;
}
memcpy(array, array_list->items, array_list->size * sizeof(void *));
memcpy(array, array_list->items, array_list->size * sizeof(void*));
return array;
}
src/shared/array_list.h
+7 -7
View File
@@ -6,16 +6,16 @@
#define INITIAL_ARRAY_SIZE 100
typedef struct ArrayList {
void **items;
void** items;
int size;
int capacity;
void (*item_destroyer)(void *item);
void (*item_destroyer)(void* item);
} ArrayList;
ArrayList *array_list_create(void (*item_destroyer)(void *item));
void array_list_delete(ArrayList *array_list);
bool array_list_extend(ArrayList *array_list);
bool array_list_add(ArrayList *array_list, void *item);
void **array_list_to_array(ArrayList *array_list);
ArrayList* array_list_create(void (*item_destroyer)(void* item));
void array_list_delete(ArrayList* array_list);
bool array_list_extend(ArrayList* array_list);
bool array_list_add(ArrayList* array_list, void* item);
void** array_list_to_array(const ArrayList* array_list);
#endif
src/shared/chunk.c
+32 -34
View File
@@ -12,14 +12,14 @@
#include "metadata.h"
#include "protocol.h"
Chunk *chunk_create(File **items, int element_count) {
Chunk *chunk = (Chunk *)malloc(sizeof(Chunk));
Chunk* chunk_create(File** items, int element_count) {
Chunk* chunk = (Chunk*)malloc(sizeof(Chunk));
if (chunk == NULL) {
perror("ERROR: Could not allocate memory for chunk structure");
return NULL;
}
chunk->items = (File **)malloc(element_count * sizeof(File *));
chunk->items = (File**)malloc(element_count * sizeof(File*));
if (chunk->items == NULL) {
free(chunk);
return NULL;
@@ -32,11 +32,11 @@ Chunk *chunk_create(File **items, int element_count) {
return chunk;
}
void chunk_destroy(void *item) {
void chunk_destroy(void* item) {
if (item == NULL) {
return;
}
Chunk *chunk = (Chunk *)item;
Chunk* chunk = (Chunk*)item;
for (int i = 0; i < chunk->element_count; ++i) {
if (chunk->items[i] != NULL) {
file_destroy(chunk->items[i]);
@@ -46,26 +46,25 @@ void chunk_destroy(void *item) {
free(chunk);
}
static unsigned long long per_file_serialize_size(File *file, bool use_metadata) {
static unsigned long long per_file_serialize_size(File* file, bool use_metadata) {
return sizeof(size_t) + strlen(file->path) +
(use_metadata ? sizeof(int) + (file->metadata ? FILE_METADATA_WIRE_SIZE : 0) : 0) +
sizeof(size_t) + file->data->size;
}
Data *chunk_serialize(Chunk *chunk, bool use_metadata) {
Data* chunk_serialize(Chunk* chunk, bool use_metadata) {
unsigned long long data_size = 0;
for (int i = 0; i < chunk->element_count; i++) {
data_size += per_file_serialize_size(chunk->items[i], use_metadata);
}
Data *data = data_create_empty(data_size);
Data* data = data_create_empty(data_size);
if (data == NULL) {
log_message(LOG_LEVEL_ERROR,
"Could not allocate memory for chunk serialization");
log_message(LOG_LEVEL_ERROR, "Could not allocate memory for chunk serialization");
return NULL;
}
char *data_pointer = data->data;
char* data_pointer = data->data;
for (int i = 0; i < chunk->element_count; i++) {
File *file = chunk->items[i];
File* file = chunk->items[i];
size_t path_len = strlen(file->path);
memcpy(data_pointer, &path_len, sizeof(size_t));
data_pointer += sizeof(size_t);
@@ -84,9 +83,9 @@ Data *chunk_serialize(Chunk *chunk, bool use_metadata) {
return data;
}
Chunk *chunk_deserialize(Data *data, bool use_metadata) {
ArrayList *files = array_list_create(file_destroy);
char *data_pointer = data->data;
Chunk* chunk_deserialize(Data* data, bool use_metadata) {
ArrayList* files = array_list_create(file_destroy);
char* data_pointer = data->data;
size_t remaining_size = data->size;
while (remaining_size > 0) {
@@ -96,7 +95,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
return NULL;
}
size_t path_len = *(size_t *)data_pointer;
size_t path_len = *(size_t*)data_pointer;
data_pointer += sizeof(size_t);
remaining_size -= sizeof(size_t);
@@ -106,7 +105,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
return NULL;
}
char *path = malloc(path_len + 1);
char* path = malloc(path_len + 1);
if (path == NULL) {
perror("Could not allocate memory for file path");
array_list_delete(files);
@@ -117,7 +116,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
data_pointer += path_len;
remaining_size -= path_len;
File *file = file_create(path);
File* file = file_create(path);
free(path);
if (use_metadata) {
@@ -133,7 +132,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
return NULL;
}
size_t file_data_size = *(size_t *)data_pointer;
size_t file_data_size = *(size_t*)data_pointer;
data_pointer += sizeof(size_t);
remaining_size -= sizeof(size_t);
@@ -143,7 +142,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
return NULL;
}
void *file_data = malloc(file_data_size);
void* file_data = malloc(file_data_size);
if (file_data == NULL) {
perror("Could not allocate memory for file data");
array_list_delete(files);
@@ -158,8 +157,8 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
array_list_add(files, file);
}
File **file_array = (File **)array_list_to_array(files);
Chunk *chunk = chunk_create(file_array, files->size);
File** file_array = (File**)array_list_to_array(files);
Chunk* chunk = chunk_create(file_array, files->size);
free(file_array);
files->item_destroyer = NULL;
@@ -168,24 +167,26 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
return chunk;
}
Data *chunk_compress(Chunk *chunk, int compression_level, bool use_metadata) {
Data* chunk_compress(Chunk* chunk, int compression_level, bool use_metadata) {
log_message(LOG_LEVEL_DEBUG, "Starting to compress chunk");
Data *serialized = chunk_serialize(chunk, use_metadata);
if (serialized == NULL) return NULL;
Data *compressed = data_compress(serialized, compression_level);
Data* serialized = chunk_serialize(chunk, use_metadata);
if (serialized == NULL)
return NULL;
Data* compressed = data_compress(serialized, compression_level);
data_destroy(serialized);
if (compressed == NULL) return NULL;
if (compressed == NULL)
return NULL;
log_message(LOG_LEVEL_DEBUG, "Chunk successfully compressed");
return compressed;
}
Chunk *receive_chunk_data(int fd, Config *config) {
Data *chunk_data = receive_data(fd);
Chunk* receive_chunk_data(int fd, const Config* config) {
Data* chunk_data = receive_data(fd);
if (chunk_data == NULL) {
log_message(LOG_LEVEL_ERROR, "Failed to receive chunk data");
return NULL;
}
Data *data_to_process = chunk_data;
Data* data_to_process = chunk_data;
if (config->use_compression) {
data_to_process = data_decompress(chunk_data);
data_destroy(chunk_data);
@@ -194,12 +195,9 @@ Chunk *receive_chunk_data(int fd, Config *config) {
return NULL;
}
}
Chunk *chunk = chunk_deserialize(data_to_process, config->use_metadata);
Chunk* chunk = chunk_deserialize(data_to_process, config->use_metadata);
data_destroy(data_to_process);
if (chunk == NULL)
log_message(LOG_LEVEL_ERROR, "Failed to deserialize chunk, skipping");
return chunk;
}
src/shared/chunk.h
+7 -7
View File
@@ -10,15 +10,15 @@
#define DESIRED_CHUNK_SIZE (10 * 1024 * 1024)
typedef struct {
File **items;
File** items;
int element_count;
} Chunk;
Chunk *chunk_create(File **items, int element_count);
void chunk_destroy(void *chunk);
Data *chunk_serialize(Chunk *chunk, bool use_metadata);
Chunk *chunk_deserialize(Data *data, bool use_metadata);
Data *chunk_compress(Chunk *chunk, int compression_level, bool use_metadata);
Chunk *receive_chunk_data(int fd, Config *config);
Chunk* chunk_create(File** items, int element_count);
void chunk_destroy(void* chunk);
Data* chunk_serialize(Chunk* chunk, bool use_metadata);
Chunk* chunk_deserialize(Data* data, bool use_metadata);
Data* chunk_compress(Chunk* chunk, int compression_level, bool use_metadata);
Chunk* receive_chunk_data(int fd, const Config* config);
#endif
src/shared/compression.c
+16 -19
View File
@@ -6,14 +6,15 @@
#define INITIAL_DECOMPRESS_BUF_SIZE (1024 * 1024)
Data *data_compress(Data *data_to_compress, int compression_level) {
Data* data_compress(Data* data_to_compress, int compression_level) {
(void)compression_level;
log_message(LOG_LEVEL_DEBUG, "Starting to compress data");
size_t dst_size = ZSTD_compressBound(data_to_compress->size);
Data *compressed_data = data_create_empty(dst_size);
if (compressed_data == NULL) return NULL;
Data* compressed_data = data_create_empty(dst_size);
if (compressed_data == NULL)
return NULL;
ZSTD_CCtx *cctx = ZSTD_createCCtx();
ZSTD_CCtx* cctx = ZSTD_createCCtx();
if (!cctx) {
log_message(LOG_LEVEL_ERROR, "Failed to create ZSTD compression context");
data_destroy(compressed_data);
@@ -27,8 +28,7 @@ Data *data_compress(Data *data_to_compress, int compression_level) {
do {
ret = ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);
if (ZSTD_isError(ret)) {
log_message(LOG_LEVEL_ERROR, "Compression failed: %s",
ZSTD_getErrorName(ret));
log_message(LOG_LEVEL_ERROR, "Compression failed: %s", ZSTD_getErrorName(ret));
ZSTD_freeCCtx(cctx);
data_destroy(compressed_data);
return NULL;
@@ -43,27 +43,25 @@ Data *data_compress(Data *data_to_compress, int compression_level) {
return compressed_data;
}
Data *data_decompress(Data *compressed_data) {
Data* data_decompress(Data* compressed_data) {
log_message(LOG_LEVEL_DEBUG, "Start to decompress data");
unsigned long long dst_size = ZSTD_getFrameContentSize(
compressed_data->data, compressed_data->size);
unsigned long long dst_size =
ZSTD_getFrameContentSize(compressed_data->data, compressed_data->size);
if (ZSTD_isError(dst_size)) {
log_message(LOG_LEVEL_ERROR, "Failed to get decompressed size: %s",
ZSTD_getErrorName(dst_size));
return NULL;
}
ZSTD_DCtx *dctx = ZSTD_createDCtx();
ZSTD_DCtx* dctx = ZSTD_createDCtx();
if (!dctx) {
log_message(LOG_LEVEL_ERROR,
"Failed to create ZSTD decompression context");
log_message(LOG_LEVEL_ERROR, "Failed to create ZSTD decompression context");
return NULL;
}
size_t buf_size = (!ZSTD_isError(dst_size) && dst_size > 0)
? (size_t)dst_size
: INITIAL_DECOMPRESS_BUF_SIZE;
Data *uncompressed_data = data_create_empty(buf_size);
size_t buf_size =
(!ZSTD_isError(dst_size) && dst_size > 0) ? (size_t)dst_size : INITIAL_DECOMPRESS_BUF_SIZE;
Data* uncompressed_data = data_create_empty(buf_size);
if (!uncompressed_data) {
log_message(LOG_LEVEL_ERROR, "Failed to allocate decompression buffer");
ZSTD_freeDCtx(dctx);
@@ -77,15 +75,14 @@ Data *data_decompress(Data *compressed_data) {
do {
ret = ZSTD_decompressStream(dctx, &output, &input);
if (ZSTD_isError(ret)) {
log_message(LOG_LEVEL_ERROR, "Decompression failed: %s",
ZSTD_getErrorName(ret));
log_message(LOG_LEVEL_ERROR, "Decompression failed: %s", ZSTD_getErrorName(ret));
ZSTD_freeDCtx(dctx);
data_destroy(uncompressed_data);
return NULL;
}
if (ret > 0 && output.pos == output.size) {
buf_size *= 2;
void *new_data = realloc(uncompressed_data->data, buf_size);
void* new_data = realloc(uncompressed_data->data, buf_size);
if (!new_data) {
log_message(LOG_LEVEL_ERROR, "Failed to grow decompression buffer");
ZSTD_freeDCtx(dctx);
src/shared/compression.h
+2 -2
View File
@@ -3,7 +3,7 @@
#include "data.h"
Data *data_compress(Data *data_to_compress, int compression_level);
Data *data_decompress(Data *compressed_data);
Data* data_compress(Data* data_to_compress, int compression_level);
Data* data_decompress(Data* compressed_data);
#endif
src/shared/config.c
+94 -53
View File
@@ -7,14 +7,12 @@
#include <stdlib.h>
#include <string.h>
Config *config_create(char *version, char *send_directory,
char *receive_directory, bool save_to_disk,
bool use_multithreading, bool use_chunk_serialization,
bool use_compression, bool use_metadata,
int compression_level, bool use_sendfile,
unsigned long long chunk_size) {
Config* config_create(char* version, char* send_directory, char* receive_directory,
bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
bool use_compression, bool use_metadata, int compression_level,
bool use_sendfile, unsigned long long chunk_size) {
Config *config = malloc(sizeof(Config));
Config* config = malloc(sizeof(Config));
config->version = version;
config->send_directory = send_directory;
config->receive_root_directory = receive_directory;
@@ -46,28 +44,33 @@ Config *config_create(char *version, char *send_directory,
return config;
}
bool is_remote_dest(const char *s) {
if (s == NULL) return false;
const char *colon = strchr(s, ':');
if (colon == NULL) return false;
if (colon == s) return false;
for (const char *p = s; p < colon; p++) {
if (*p == '/') return false;
bool is_remote_dest(const char* s) {
if (s == NULL)
return false;
const char* colon = strchr(s, ':');
if (colon == NULL)
return false;
if (colon == s)
return false;
for (const char* p = s; p < colon; p++) {
if (*p == '/')
return false;
}
return true;
}
void config_parse_ssh_dest(Config *config) {
if (!is_remote_dest(config->receive_root_directory)) return;
void config_parse_ssh_dest(Config* config) {
if (!is_remote_dest(config->receive_root_directory))
return;
config->transport = TRANSPORT_SSH;
config->ssh_destination = str_dup(config->receive_root_directory);
char *colon = strchr(config->receive_root_directory, ':');
char *path = str_dup(colon + 1);
const char* colon = strchr(config->receive_root_directory, ':');
char* path = str_dup(colon + 1);
free(config->receive_root_directory);
config->receive_root_directory = path;
}
void config_delete(Config *config) {
void config_delete(Config* config) {
free(config->version);
free(config->send_directory);
free(config->receive_root_directory);
@@ -84,22 +87,36 @@ void config_delete(Config *config) {
free(config);
}
bool config_send(int file_descriptor, Config *config) {
if (!send_str(file_descriptor, config->version)) return false;
if (!send_str(file_descriptor, config->send_directory)) return false;
if (!send_str(file_descriptor, config->receive_root_directory)) return false;
if (!send_int(file_descriptor, config->save_to_disk)) return false;
if (!send_int(file_descriptor, config->use_multithreading)) return false;
if (!send_int(file_descriptor, config->use_chunk_serialization)) return false;
if (!send_int(file_descriptor, config->use_compression)) return false;
if (!send_int(file_descriptor, config->use_metadata)) return false;
if (!send_int(file_descriptor, config->compression_level)) return false;
if (!send_int(file_descriptor, (int)config->chunk_size)) return false;
if (!send_int(file_descriptor, config->use_sendfile)) return false;
if (!send_int(file_descriptor, config->use_delete)) return false;
if (!send_int(file_descriptor, config->use_incremental)) return false;
bool config_send(int file_descriptor, Config* config) {
if (!send_str(file_descriptor, config->version))
return false;
if (!send_str(file_descriptor, config->send_directory))
return false;
if (!send_str(file_descriptor, config->receive_root_directory))
return false;
if (!send_int(file_descriptor, config->save_to_disk))
return false;
if (!send_int(file_descriptor, config->use_multithreading))
return false;
if (!send_int(file_descriptor, config->use_chunk_serialization))
return false;
if (!send_int(file_descriptor, config->use_compression))
return false;
if (!send_int(file_descriptor, config->use_metadata))
return false;
if (!send_int(file_descriptor, config->compression_level))
return false;
if (!send_int(file_descriptor, (int)config->chunk_size))
return false;
if (!send_int(file_descriptor, config->use_sendfile))
return false;
if (!send_int(file_descriptor, config->use_delete))
return false;
if (!send_int(file_descriptor, config->use_incremental))
return false;
Status status;
if (!receive_status(file_descriptor, &status)) return false;
if (!receive_status(file_descriptor, &status))
return false;
if (status != STATUS_OK) {
log_message(LOG_LEVEL_ERROR, "Error transmitting config");
return false;
@@ -107,43 +124,66 @@ bool config_send(int file_descriptor, Config *config) {
return true;
}
Config *config_receive(int file_descriptor) {
Config *config = (Config *)malloc(sizeof(Config));
if (config == NULL) return NULL;
Config* config_receive(int file_descriptor) {
Config* config = (Config*)malloc(sizeof(Config));
if (config == NULL)
return NULL;
config->version = receive_str(file_descriptor);
if (!config->version) { free(config); return NULL; }
if (!config->version) {
free(config);
return NULL;
}
if (strcmp(config->version, PROTOCOL_VERSION) != 0) {
fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n",
config->version, PROTOCOL_VERSION);
fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n", config->version,
PROTOCOL_VERSION);
free(config->version);
free(config);
send_status(file_descriptor, STATUS_ERROR);
return NULL;
}
config->send_directory = receive_str(file_descriptor);
if (!config->send_directory) { free(config->version); free(config); return NULL; }
if (!config->send_directory) {
free(config->version);
free(config);
return NULL;
}
config->receive_root_directory = receive_str(file_descriptor);
if (!config->receive_root_directory) { free(config->version); free(config->send_directory); free(config); return NULL; }
if (!config->receive_root_directory) {
free(config->version);
free(config->send_directory);
free(config);
return NULL;
}
int tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->save_to_disk = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_multithreading = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_chunk_serialization = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_compression = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_metadata = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->compression_level = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->chunk_size = (unsigned long long)tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_sendfile = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_delete = tmp;
if (!receive_int(file_descriptor, &tmp)) goto error;
if (!receive_int(file_descriptor, &tmp))
goto error;
config->use_incremental = tmp;
config->show_progress = false;
config->dry_run = false;
@@ -160,7 +200,8 @@ Config *config_receive(int file_descriptor) {
config->tls_cert = NULL;
config->tls_key = NULL;
config->tls_ca = NULL;
if (!send_status(file_descriptor, STATUS_OK)) goto error;
if (!send_status(file_descriptor, STATUS_OK))
goto error;
return config;
error:
src/shared/config.h
+19 -24
View File
@@ -3,15 +3,12 @@
#include <stdbool.h>
typedef enum {
TRANSPORT_TCP,
TRANSPORT_SSH
} TransportType;
typedef enum { TRANSPORT_TCP, TRANSPORT_SSH } TransportType;
typedef struct Config {
char *version;
char *send_directory;
char *receive_root_directory;
char* version;
char* send_directory;
char* receive_root_directory;
bool save_to_disk;
bool use_multithreading;
bool use_chunk_serialization;
@@ -25,33 +22,31 @@ typedef struct Config {
unsigned long long chunk_size;
int ssh_port;
TransportType transport;
char *ssh_destination;
char **exclude_patterns;
char* ssh_destination;
char** exclude_patterns;
int exclude_count;
char **include_patterns;
char** include_patterns;
int include_count;
unsigned long long max_size;
unsigned long long min_size;
bool use_incremental;
bool use_tls;
char *tls_cert;
char *tls_key;
char *tls_ca;
char* tls_cert;
char* tls_key;
char* tls_ca;
} Config;
#define PROTOCOL_VERSION "1.1.0"
#define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)
Config *config_create(char *version, char *send_directory,
char *receive_directory, bool save_to_disk,
bool use_multithreading, bool use_chunk_serialization,
bool use_compression, bool use_metadata,
int compression_level, bool use_sendfile,
unsigned long long chunk_size);
void config_delete(Config *config);
bool config_send(int file_descriptor, Config *config);
Config *config_receive(int file_descriptor);
bool is_remote_dest(const char *s);
void config_parse_ssh_dest(Config *config);
Config* config_create(char* version, char* send_directory, char* receive_directory,
bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
bool use_compression, bool use_metadata, int compression_level,
bool use_sendfile, unsigned long long chunk_size);
void config_delete(Config* config);
bool config_send(int file_descriptor, Config* config);
Config* config_receive(int file_descriptor);
bool is_remote_dest(const char* s);
void config_parse_ssh_dest(Config* config);
#endif
src/shared/data.c
+9 -8
View File
@@ -2,8 +2,8 @@
#include "log.h"
#include "stdlib.h"
Data *data_create_empty(size_t data_size) {
void *data = malloc(data_size);
Data* data_create_empty(size_t data_size) {
void* data = malloc(data_size);
if (data == NULL) {
log_message(LOG_LEVEL_ERROR, "Could not allocate memory for empty data");
return NULL;
@@ -11,8 +11,8 @@ Data *data_create_empty(size_t data_size) {
return data_create(data, data_size);
}
Data *data_create_reserve(size_t size) {
Data *d = malloc(sizeof(Data));
Data* data_create_reserve(size_t size) {
Data* d = malloc(sizeof(Data));
if (d == NULL) {
log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
return NULL;
@@ -22,8 +22,8 @@ Data *data_create_reserve(size_t size) {
return d;
}
Data *data_create(void *data, size_t data_size) {
Data *new_data = malloc(sizeof(Data));
Data* data_create(void* data, size_t data_size) {
Data* new_data = malloc(sizeof(Data));
if (new_data == NULL) {
log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
free(data);
@@ -34,8 +34,9 @@ Data *data_create(void *data, size_t data_size) {
return new_data;
}
void data_destroy(Data *data) {
if (data == NULL) return;
void data_destroy(Data* data) {
if (data == NULL)
return;
free(data->data);
free(data);
}
src/shared/data.h
+5 -5
View File
@@ -4,13 +4,13 @@
#include "stdlib.h"
typedef struct {
void *data;
void* data;
size_t size;
} Data;
Data *data_create_empty(size_t data_size);
Data *data_create_reserve(size_t size);
Data *data_create(void *data, size_t data_size);
void data_destroy(Data *data);
Data* data_create_empty(size_t data_size);
Data* data_create_reserve(size_t size);
Data* data_create(void* data, size_t data_size);
void data_destroy(Data* data);
#endif
src/shared/file.c
+89 -58
View File
@@ -19,15 +19,15 @@
#include "protocol.h"
#include "utils.h"
File *file_create(const char *path) {
File *file = (File *)malloc(sizeof(File));
File* file_create(const char* path) {
File* file = (File*)malloc(sizeof(File));
if (file == NULL) {
perror("ERROR: Could not allocate memory for file struct");
return NULL;
}
int path_len = strlen(path);
file->path = (char *)malloc(path_len + 1);
file->path = (char*)malloc(path_len + 1);
if (file->path == NULL) {
free(file);
return NULL;
@@ -44,10 +44,10 @@ File *file_create(const char *path) {
return file;
}
void file_destroy(void *item) {
void file_destroy(void* item) {
if (item == NULL)
return;
File *file = (File *)item;
File* file = (File*)item;
data_destroy(file->data);
file->data = NULL;
file_metadata_destroy(file->metadata);
@@ -57,8 +57,8 @@ void file_destroy(void *item) {
free(file);
}
FileMetadata *file_metadata_create(struct stat *stats) {
FileMetadata *m = malloc(sizeof(FileMetadata));
FileMetadata* file_metadata_create(const struct stat* stats) {
FileMetadata* m = malloc(sizeof(FileMetadata));
if (m == NULL) {
perror("ERROR: Could not allocate memory for file metadata");
return NULL;
@@ -75,12 +75,13 @@ FileMetadata *file_metadata_create(struct stat *stats) {
return m;
}
void file_metadata_destroy(void *metadata) {
void file_metadata_destroy(void* metadata) {
free(metadata);
}
bool file_load_data(File *file) {
if (file == NULL) return false;
bool file_load_data(File* file) {
if (file == NULL)
return false;
if (file->data->data == NULL) {
file->data->data = malloc(file->data->size);
if (file->data->data == NULL) {
@@ -96,9 +97,10 @@ bool file_load_data(File *file) {
return true;
}
bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path) {
Data *data_to_send = file->data;
Data *compressed_data = NULL;
bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
int compression_level, bool send_path) {
Data* data_to_send = file->data;
Data* compressed_data = NULL;
if (compression_level > 0) {
compressed_data = data_compress(file->data, compression_level);
if (compressed_data == NULL) {
@@ -123,18 +125,24 @@ bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata,
return true;
}
bool file_save_to_disk(const char *root_directory, File *file) {
char *disk_path = path_cat((char *)root_directory, file->path);
if (disk_path == NULL) return false;
bool file_save_to_disk(const char* root_directory, File* file) {
char* disk_path = path_cat((char*)root_directory, file->path);
if (disk_path == NULL)
return false;
bool ok = to_disk(disk_path, file->data->data, file->data->size);
if (ok) file_restore_metadata(disk_path, file->metadata);
if (ok)
file_restore_metadata(disk_path, file->metadata);
free(disk_path);
return ok;
}
File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipped = false;
char *check_path = receive_str(fd);
if (check_path == NULL) { send_status(fd, STATUS_ERROR); return NULL; }
File* receive_incremental_check(int fd, Config* config, bool* skipped) {
*skipped = false;
char* check_path = receive_str(fd);
if (check_path == NULL) {
send_status(fd, STATUS_ERROR);
return NULL;
}
unsigned long long check_size;
long long check_mtime;
@@ -145,36 +153,48 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipp
return NULL;
}
char *full_path = path_cat(config->receive_root_directory, check_path);
char* full_path = path_cat(config->receive_root_directory, check_path);
struct stat st;
bool match = false;
if (full_path && stat(full_path, &st) == 0 &&
(unsigned long long)st.st_size == check_size &&
if (full_path && stat(full_path, &st) == 0 && (unsigned long long)st.st_size == check_size &&
(long long)st.st_mtime == check_mtime) {
match = true;
}
free(full_path);
if (match) {
if (!send_status(fd, STATUS_OK)) { free(check_path); return NULL; }
if (!send_status(fd, STATUS_OK)) {
free(check_path);
return NULL;
}
free(check_path);
*skipped = true;
return NULL;
}
if (!send_status(fd, STATUS_NEXT)) { free(check_path); return NULL; }
if (!send_status(fd, STATUS_NEXT)) {
free(check_path);
return NULL;
}
File *file = file_create(check_path);
File* file = file_create(check_path);
free(check_path);
if (file == NULL) { send_status(fd, STATUS_ERROR); return NULL; }
if (file == NULL) {
send_status(fd, STATUS_ERROR);
return NULL;
}
if (config->use_metadata) {
int meta_ok = 1;
file->metadata = metadata_receive(fd, &meta_ok);
if (!meta_ok) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
if (!meta_ok) {
file_destroy(file);
send_status(fd, STATUS_ERROR);
return NULL;
}
}
Data *file_data = receive_data(fd);
Data* file_data = receive_data(fd);
if (file_data == NULL) {
file_destroy(file);
send_status(fd, STATUS_ERROR);
@@ -182,9 +202,13 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipp
}
if (config->use_compression) {
Data *uncompressed = data_decompress(file_data);
Data* uncompressed = data_decompress(file_data);
data_destroy(file_data);
if (uncompressed == NULL) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
if (uncompressed == NULL) {
file_destroy(file);
send_status(fd, STATUS_ERROR);
return NULL;
}
file_data = uncompressed;
}
@@ -193,15 +217,15 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) { *skipp
return file;
}
bool to_disk(const char *path, const void *data, unsigned long long data_size) {
char *directory = str_dup(path);
char *dir_to_free = directory;
bool to_disk(const char* path, const void* data, unsigned long long data_size) {
char* directory = str_dup(path);
char* dir_to_free = directory;
directory = dirname(directory);
if (!mkdir_r(directory)) {
free(dir_to_free);
return false;
}
FILE *file_pointer = fopen(path, "wb");
FILE* file_pointer = fopen(path, "wb");
if (file_pointer == NULL) {
perror("Could not open File");
free(dir_to_free);
@@ -218,9 +242,11 @@ bool to_disk(const char *path, const void *data, unsigned long long data_size) {
return true;
}
bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, bool send_path) {
if (send_path && !send_str(file_descriptor, file->path)) return false;
if (use_metadata && !metadata_send(file_descriptor, file->metadata)) return false;
bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, bool send_path) {
if (send_path && !send_str(file_descriptor, file->path))
return false;
if (use_metadata && !metadata_send(file_descriptor, file->metadata))
return false;
int fd = open(file->path, O_RDONLY);
if (fd == -1) {
@@ -248,24 +274,29 @@ bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, bool
return true;
}
File *file_receive(Config *config, int file_descriptor) {
char *path = receive_str(file_descriptor);
if (path == NULL) return NULL;
File *file = file_create(path);
File* file_receive(const Config* config, int file_descriptor) {
char* path = receive_str(file_descriptor);
if (path == NULL)
return NULL;
File* file = file_create(path);
free(path);
if (file == NULL) return NULL;
if (file == NULL)
return NULL;
if (config->use_metadata) {
int meta_ok = 1;
file->metadata = metadata_receive(file_descriptor, &meta_ok);
if (!meta_ok) { file_destroy(file); return NULL; }
if (!meta_ok) {
file_destroy(file);
return NULL;
}
}
Data *file_data = receive_data(file_descriptor);
Data* file_data = receive_data(file_descriptor);
if (file_data == NULL) {
file_destroy(file);
return NULL;
}
if (config->use_compression) {
Data *file_data_uncompressed = data_decompress(file_data);
Data* file_data_uncompressed = data_decompress(file_data);
data_destroy(file_data);
if (file_data_uncompressed == NULL) {
file_destroy(file);
@@ -278,14 +309,13 @@ File *file_receive(Config *config, int file_descriptor) {
return file;
}
size_t file_content_to_buffer(File *file) {
FILE *file_pointer = fopen(file->path, "rb");
size_t file_content_to_buffer(File* file) {
FILE* file_pointer = fopen(file->path, "rb");
if (file_pointer == NULL) {
perror("Could not open the file!");
return 0;
}
size_t bytes_read =
fread(file->data->data, 1, file->data->size, file_pointer);
size_t bytes_read = fread(file->data->data, 1, file->data->size, file_pointer);
if (bytes_read != (size_t)file->data->size) {
fclose(file_pointer);
perror("Read unexpected number of bytes from File!");
@@ -295,21 +325,22 @@ size_t file_content_to_buffer(File *file) {
return bytes_read;
}
int receive_manifest(int fd, Config *config, int *next_status) {
int receive_manifest(int fd, const Config* config, int* next_status) {
int count;
if (!receive_int(fd, &count)) return -1;
ArrayList *manifest = array_list_create(free);
if (!receive_int(fd, &count))
return -1;
ArrayList* manifest = array_list_create(free);
if (manifest) {
for (int i = 0; i < count; i++) {
char *s = receive_str(fd);
if (s) array_list_add(manifest, s);
char* s = receive_str(fd);
if (s)
array_list_add(manifest, s);
}
fprintf(stderr, "Deleting files not in manifest...\n");
delete_extras(config->receive_root_directory, manifest);
array_list_delete(manifest);
}
if (!receive_status(fd, next_status)) return -1;
if (!receive_status(fd, next_status))
return -1;
return 0;
}
src/shared/file.h
+17 -16
View File
@@ -15,23 +15,24 @@ typedef struct {
} FileMetadata;
typedef struct {
char *path;
Data *data;
FileMetadata *metadata;
char* path;
Data* data;
FileMetadata* metadata;
} File;
File *file_create(const char *path);
void file_destroy(void *item);
bool file_load_data(File *file);
File *file_receive(Config *config, int file_descriptor);
bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path);
bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, bool send_path);
size_t file_content_to_buffer(File *file);
FileMetadata *file_metadata_create(struct stat *stats);
void file_metadata_destroy(void *metadata);
bool to_disk(const char *path, const void *data, unsigned long long data_size);
bool file_save_to_disk(const char *root_directory, File *file);
File *receive_incremental_check(int fd, Config *config, bool *skipped);
int receive_manifest(int fd, Config *config, int *next_status);
File* file_create(const char* path);
void file_destroy(void* item);
bool file_load_data(File* file);
File* file_receive(const Config* config, int file_descriptor);
bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
int compression_level, bool send_path);
bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, bool send_path);
size_t file_content_to_buffer(File* file);
FileMetadata* file_metadata_create(const struct stat* stats);
void file_metadata_destroy(void* metadata);
bool to_disk(const char* path, const void* data, unsigned long long data_size);
bool file_save_to_disk(const char* root_directory, File* file);
File* receive_incremental_check(int fd, Config* config, bool* skipped);
int receive_manifest(int fd, const Config* config, int* next_status);
#endif
src/shared/log.c
+5 -6
View File
@@ -3,22 +3,21 @@
#include <stdio.h>
#include <time.h>
static const char *log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
static const char* log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
static LogLevel current_log_level = LOG_LEVEL_WARNING;
void set_log_level(LogLevel level) {
current_log_level = level;
}
void log_message(LogLevel log_level, char *format, ...) {
void log_message(LogLevel log_level, char* format, ...) {
if (log_level < current_log_level)
return;
time_t now = time(NULL);
struct tm *t = localtime(&now);
const struct tm* t = localtime(&now);
fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900,
t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec,
log_level_strings[log_level]);
fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900, t->tm_mon + 1,
t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, log_level_strings[log_level]);
va_list args;
va_start(args, format);
src/shared/log.h
+2 -7
View File
@@ -1,14 +1,9 @@
#ifndef LOG_H
#define LOG_H
typedef enum {
LOG_LEVEL_DEBUG,
LOG_LEVEL_INFO,
LOG_LEVEL_WARNING,
LOG_LEVEL_ERROR
} LogLevel;
typedef enum { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR } LogLevel;
void log_message(LogLevel log_level, char *message, ...);
void log_message(LogLevel log_level, char* message, ...);
void set_log_level(LogLevel level);
#endif
src/shared/metadata.c
+40 -22
View File
@@ -8,35 +8,45 @@
#include <time.h>
#include <unistd.h>
void metadata_to_buf(char **buf, FileMetadata *m) {
void metadata_to_buf(char** buf, const FileMetadata* m) {
int present = (m != NULL) ? 1 : 0;
memcpy(*buf, &present, sizeof(int));
*buf += sizeof(int);
if (m == NULL)
return;
memcpy(*buf, &m->mode, sizeof(mode_t)); *buf += sizeof(mode_t);
memcpy(*buf, &m->uid, sizeof(uid_t)); *buf += sizeof(uid_t);
memcpy(*buf, &m->gid, sizeof(gid_t)); *buf += sizeof(gid_t);
memcpy(*buf, &m->mtime_sec, sizeof(time_t)); *buf += sizeof(time_t);
memcpy(*buf, &m->mtime_nsec, sizeof(long)); *buf += sizeof(long);
memcpy(*buf, &m->mode, sizeof(mode_t));
*buf += sizeof(mode_t);
memcpy(*buf, &m->uid, sizeof(uid_t));
*buf += sizeof(uid_t);
memcpy(*buf, &m->gid, sizeof(gid_t));
*buf += sizeof(gid_t);
memcpy(*buf, &m->mtime_sec, sizeof(time_t));
*buf += sizeof(time_t);
memcpy(*buf, &m->mtime_nsec, sizeof(long));
*buf += sizeof(long);
}
FileMetadata *metadata_from_buf(char **buf) {
FileMetadata* metadata_from_buf(char** buf) {
int present;
memcpy(&present, *buf, sizeof(int));
*buf += sizeof(int);
if (!present)
return NULL;
FileMetadata *m = malloc(sizeof(FileMetadata));
memcpy(&m->mode, *buf, sizeof(mode_t)); *buf += sizeof(mode_t);
memcpy(&m->uid, *buf, sizeof(uid_t)); *buf += sizeof(uid_t);
memcpy(&m->gid, *buf, sizeof(gid_t)); *buf += sizeof(gid_t);
memcpy(&m->mtime_sec, *buf, sizeof(time_t)); *buf += sizeof(time_t);
memcpy(&m->mtime_nsec, *buf, sizeof(long)); *buf += sizeof(long);
FileMetadata* m = malloc(sizeof(FileMetadata));
memcpy(&m->mode, *buf, sizeof(mode_t));
*buf += sizeof(mode_t);
memcpy(&m->uid, *buf, sizeof(uid_t));
*buf += sizeof(uid_t);
memcpy(&m->gid, *buf, sizeof(gid_t));
*buf += sizeof(gid_t);
memcpy(&m->mtime_sec, *buf, sizeof(time_t));
*buf += sizeof(time_t);
memcpy(&m->mtime_nsec, *buf, sizeof(long));
*buf += sizeof(long);
return m;
}
bool metadata_send(int file_descriptor, FileMetadata *m) {
bool metadata_send(int file_descriptor, FileMetadata* m) {
if (m == NULL) {
int zero = 0;
return send_n_data(file_descriptor, &zero, sizeof(int));
@@ -50,32 +60,40 @@ bool metadata_send(int file_descriptor, FileMetadata *m) {
send_n_data(file_descriptor, &m->mtime_nsec, sizeof(long));
}
FileMetadata *metadata_receive(int file_descriptor, int *ok) {
FileMetadata* metadata_receive(int file_descriptor, int* ok) {
int present;
if (!receive_n_data(file_descriptor, &present, sizeof(int))) {
if (ok) *ok = 0;
if (ok)
*ok = 0;
return NULL;
}
if (!present) {
if (ok) *ok = 1;
if (ok)
*ok = 1;
return NULL;
}
FileMetadata* m = malloc(sizeof(FileMetadata));
if (m == NULL) {
if (ok)
*ok = 0;
return NULL;
}
FileMetadata *m = malloc(sizeof(FileMetadata));
if (m == NULL) { if (ok) *ok = 0; return NULL; }
if (!receive_n_data(file_descriptor, &m->mode, sizeof(mode_t)) ||
!receive_n_data(file_descriptor, &m->uid, sizeof(uid_t)) ||
!receive_n_data(file_descriptor, &m->gid, sizeof(gid_t)) ||
!receive_n_data(file_descriptor, &m->mtime_sec, sizeof(time_t)) ||
!receive_n_data(file_descriptor, &m->mtime_nsec, sizeof(long))) {
free(m);
if (ok) *ok = 0;
if (ok)
*ok = 0;
return NULL;
}
if (ok) *ok = 1;
if (ok)
*ok = 1;
return m;
}
void file_restore_metadata(const char *path, FileMetadata *metadata) {
void file_restore_metadata(const char* path, FileMetadata* metadata) {
if (metadata == NULL)
return;
chmod(path, metadata->mode & 07777);
src/shared/metadata.h
+7 -6
View File
@@ -5,12 +5,13 @@
#include <stdbool.h>
#include <sys/stat.h>
#define FILE_METADATA_WIRE_SIZE (sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))
#define FILE_METADATA_WIRE_SIZE \
(sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))
void metadata_to_buf(char **buf, FileMetadata *m);
FileMetadata *metadata_from_buf(char **buf);
bool metadata_send(int file_descriptor, FileMetadata *m);
FileMetadata *metadata_receive(int file_descriptor, int *ok);
void file_restore_metadata(const char *path, FileMetadata *metadata);
void metadata_to_buf(char** buf, const FileMetadata* m);
FileMetadata* metadata_from_buf(char** buf);
bool metadata_send(int file_descriptor, FileMetadata* m);
FileMetadata* metadata_receive(int file_descriptor, int* ok);
void file_restore_metadata(const char* path, FileMetadata* metadata);
#endif
src/shared/multiprocessing.c
+38 -39
View File
@@ -13,11 +13,11 @@
#include <string.h>
#include <threads.h>
PipelineContextSender *pipeline_context_sender_create(Config *config,
Queue *queue_scanner,
Queue *queue_loader) {
PipelineContextSender *context = malloc(sizeof(PipelineContextSender));
if (context == NULL) return NULL;
PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
Queue* queue_loader) {
PipelineContextSender* context = malloc(sizeof(PipelineContextSender));
if (context == NULL)
return NULL;
context->config = config;
context->queue_scanner = queue_scanner;
context->queue_loader = queue_loader;
@@ -37,7 +37,7 @@ PipelineContextSender *pipeline_context_sender_create(Config *config,
return context;
}
void pipeline_context_sender_destroy(PipelineContextSender *context) {
void pipeline_context_sender_destroy(PipelineContextSender* context) {
if (context->manifest) {
array_list_delete(context->manifest);
}
@@ -53,11 +53,11 @@ void pipeline_context_sender_destroy(PipelineContextSender *context) {
free(context);
}
PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
Queue *queue,
PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue* queue,
int file_descriptor) {
PipelineContextReceiver *context = malloc(sizeof(PipelineContextReceiver));
if (context == NULL) return NULL;
PipelineContextReceiver* context = malloc(sizeof(PipelineContextReceiver));
if (context == NULL)
return NULL;
context->config = config;
context->queue = queue;
context->file_descriptor = file_descriptor;
@@ -72,7 +72,7 @@ PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
return context;
}
void pipeline_context_receiver_destroy(PipelineContextReceiver *context) {
void pipeline_context_receiver_destroy(PipelineContextReceiver* context) {
config_delete(context->config);
queue_destroy(context->queue);
mtx_destroy(&context->mutex);
@@ -81,57 +81,57 @@ void pipeline_context_receiver_destroy(PipelineContextReceiver *context) {
free(context);
}
static void receive_chunk_enqueue(int file_descriptor,
PipelineContextReceiver *context) {
Chunk *chunk = receive_chunk_data(file_descriptor, context->config);
if (chunk == NULL) return;
static void receive_chunk_enqueue(int file_descriptor, PipelineContextReceiver* context) {
Chunk* chunk = receive_chunk_data(file_descriptor, context->config);
if (chunk == NULL)
return;
for (int i = 0; i < chunk->element_count; i++) {
File *file = chunk->items[i];
File* file = chunk->items[i];
chunk->items[i] = NULL;
queue_enqueue_multithreaded(context->queue, file, &context->mutex,
&context->condition_not_empty,
&context->condition_not_full);
&context->condition_not_empty, &context->condition_not_full);
}
chunk_destroy(chunk);
}
int receive_thread(void *pipeline_context) {
PipelineContextReceiver *context =
(PipelineContextReceiver *)pipeline_context;
int receive_thread(void* pipeline_context) {
PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
mtx_lock(&context->mutex);
int file_descriptor = context->file_descriptor;
Config *config = context->config;
Config* config = context->config;
mtx_unlock(&context->mutex);
Status status;
if (!receive_status(file_descriptor, &status)) return thrd_error;
if (!receive_status(file_descriptor, &status))
return thrd_error;
while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
if (status == STATUS_CHECK) {
bool skipped;
File *file = receive_incremental_check(file_descriptor, config, &skipped);
File* file = receive_incremental_check(file_descriptor, config, &skipped);
if (!skipped) {
if (file == NULL) return thrd_error;
if (file == NULL)
return thrd_error;
queue_enqueue_multithreaded(context->queue, file, &context->mutex,
&context->condition_not_empty,
&context->condition_not_full);
&context->condition_not_empty, &context->condition_not_full);
}
} else if (status == STATUS_CHUNK) {
receive_chunk_enqueue(file_descriptor, context);
} else {
File *file = file_receive(config, file_descriptor);
File* file = file_receive(config, file_descriptor);
if (file) {
queue_enqueue_multithreaded(context->queue, file, &context->mutex,
&context->condition_not_empty,
&context->condition_not_full);
&context->condition_not_empty, &context->condition_not_full);
} else {
log_message(LOG_LEVEL_ERROR, "Failed to receive file");
}
}
if (!receive_status(file_descriptor, &status)) return thrd_error;
if (!receive_status(file_descriptor, &status))
return thrd_error;
}
if (status == STATUS_MANIFEST) {
if (receive_manifest(file_descriptor, config, &status) != 0) return thrd_error;
if (receive_manifest(file_descriptor, config, &status) != 0)
return thrd_error;
}
mtx_lock(&context->mutex);
context->receiver_done = true;
@@ -140,18 +140,17 @@ int receive_thread(void *pipeline_context) {
return thrd_success;
}
int write_thread(void *pipeline_context) {
PipelineContextReceiver *context =
(PipelineContextReceiver *)pipeline_context;
int write_thread(void* pipeline_context) {
PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
mtx_lock(&context->mutex);
bool save_to_disk = context->config->save_to_disk;
char *root_directory = str_dup(context->config->receive_root_directory);
char* root_directory = str_dup(context->config->receive_root_directory);
mtx_unlock(&context->mutex);
while (true) {
File *file = queue_dequeue_multithreaded(
context->queue, &context->mutex, &context->condition_not_empty,
&context->condition_not_full, &context->receiver_done);
File* file =
queue_dequeue_multithreaded(context->queue, &context->mutex, &context->condition_not_empty,
&context->condition_not_full, &context->receiver_done);
if (file == NULL) {
free(root_directory);
return thrd_success;
src/shared/multiprocessing.h
+13 -15
View File
@@ -9,23 +9,23 @@
#include "queue.h"
typedef struct {
Config *config;
Queue *queue_scanner;
Config* config;
Queue* queue_scanner;
mtx_t mutex_scanner;
cnd_t condition_not_full_scanner;
cnd_t condition_not_empty_scanner;
bool scanner_done;
Queue *queue_loader;
Queue* queue_loader;
mtx_t mutex_loader;
cnd_t condition_not_full_loader;
cnd_t condition_not_empty_loader;
bool loader_done;
ArrayList *manifest;
ArrayList* manifest;
} PipelineContextSender;
typedef struct PipelineContextReceiver {
Queue *queue;
Config *config;
Queue* queue;
Config* config;
int file_descriptor;
mtx_t mutex;
cnd_t condition_not_full;
@@ -33,14 +33,12 @@ typedef struct PipelineContextReceiver {
bool receiver_done;
} PipelineContextReceiver;
PipelineContextSender *pipeline_context_sender_create(Config *config,
Queue *queue_scanner,
Queue *queue_loader);
void pipeline_context_sender_destroy(PipelineContextSender *context);
PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
Queue *queue_receiver,
PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
Queue* queue_loader);
void pipeline_context_sender_destroy(PipelineContextSender* context);
PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue* queue_receiver,
int file_descriptor);
void pipeline_context_receiver_destroy(PipelineContextReceiver *context);
int receive_thread(void *pipeline_context);
int write_thread(void *pipeline_context);
void pipeline_context_receiver_destroy(PipelineContextReceiver* context);
int receive_thread(void* pipeline_context);
int write_thread(void* pipeline_context);
#endif
src/shared/protocol.c
+41 -31
View File
@@ -10,7 +10,7 @@
static __thread int io_read_fd = -1;
static __thread int io_write_fd = -1;
static SSL *io_ssl = NULL;
static SSL* io_ssl = NULL;
static unsigned long long io_bwlimit = 0;
static long long bw_tokens = 0;
@@ -28,13 +28,14 @@ void io_set_bwlimit(unsigned long long bytes_per_sec) {
}
static void bw_throttle(size_t bytes_written) {
if (io_bwlimit == 0) return;
if (io_bwlimit == 0)
return;
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
long long elapsed_ns = (now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL +
(now.tv_nsec - bw_last_refill.tv_nsec);
long long elapsed_ns =
(now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL + (now.tv_nsec - bw_last_refill.tv_nsec);
bw_last_refill = now;
long long tokens_to_add = (long long)((double)io_bwlimit * elapsed_ns / 1000000000.0);
@@ -56,7 +57,7 @@ static void bw_throttle(size_t bytes_written) {
}
}
void io_set_ssl(SSL *ssl) {
void io_set_ssl(SSL* ssl) {
io_ssl = ssl;
}
@@ -64,7 +65,7 @@ static int io_fd(int dir_fd, int file_descriptor) {
return (dir_fd != -1) ? dir_fd : file_descriptor;
}
bool send_n_data(int file_descriptor, void *data, size_t data_size) {
bool send_n_data(int file_descriptor, void* data, size_t data_size) {
log_message(LOG_LEVEL_DEBUG, " Sending n Data: %zu", data_size);
int fd = io_fd(io_write_fd, file_descriptor);
ssize_t total_bytes_send = 0;
@@ -74,9 +75,9 @@ bool send_n_data(int file_descriptor, void *data, size_t data_size) {
chunk = 65536;
ssize_t bytes_send;
if (io_ssl)
bytes_send = SSL_write(io_ssl, (char *)data + total_bytes_send, chunk);
bytes_send = SSL_write(io_ssl, (char*)data + total_bytes_send, chunk);
else
bytes_send = write(fd, (char *)data + total_bytes_send, chunk);
bytes_send = write(fd, (char*)data + total_bytes_send, chunk);
if (bytes_send <= 0) {
log_message(LOG_LEVEL_ERROR, "Could not send data");
return false;
@@ -88,18 +89,18 @@ bool send_n_data(int file_descriptor, void *data, size_t data_size) {
return true;
}
bool receive_n_data(int file_descriptor, void *data, size_t data_size) {
bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
log_message(LOG_LEVEL_DEBUG, " Receiving n Data: %zu", data_size);
int fd = io_fd(io_read_fd, file_descriptor);
size_t total_bytes_received = 0;
while (total_bytes_received < data_size) {
ssize_t bytes_received;
if (io_ssl)
bytes_received = SSL_read(io_ssl, (char *)data + total_bytes_received,
data_size - total_bytes_received);
bytes_received =
SSL_read(io_ssl, (char*)data + total_bytes_received, data_size - total_bytes_received);
else
bytes_received = read(fd, (char *)data + total_bytes_received,
data_size - total_bytes_received);
bytes_received =
read(fd, (char*)data + total_bytes_received, data_size - total_bytes_received);
if (bytes_received <= 0) {
if (bytes_received == 0)
log_message(LOG_LEVEL_ERROR, "Connection closed while receiving data");
@@ -113,7 +114,7 @@ bool receive_n_data(int file_descriptor, void *data, size_t data_size) {
return true;
}
static const char *status_to_string(Status status) {
static const char* status_to_string(Status status) {
switch (status) {
case STATUS_OK:
return "OK";
@@ -132,19 +133,23 @@ static const char *status_to_string(Status status) {
}
}
bool send_str(int file_descriptor, char *data) {
bool send_str(int file_descriptor, char* data) {
size_t size = strlen(data);
if (!send_n_data(file_descriptor, &size, sizeof(size_t))) return false;
if (!send_n_data(file_descriptor, data, size)) return false;
if (!send_n_data(file_descriptor, &size, sizeof(size_t)))
return false;
if (!send_n_data(file_descriptor, data, size))
return false;
log_message(LOG_LEVEL_DEBUG, "Send String: %s", data);
return true;
}
char *receive_str(int file_descriptor) {
char* receive_str(int file_descriptor) {
size_t size;
if (!receive_n_data(file_descriptor, &size, sizeof(size_t))) return NULL;
char *data = (char *)malloc(size + 1);
if (data == NULL) return NULL;
if (!receive_n_data(file_descriptor, &size, sizeof(size_t)))
return NULL;
char* data = (char*)malloc(size + 1);
if (data == NULL)
return NULL;
if (!receive_n_data(file_descriptor, data, size)) {
free(data);
return NULL;
@@ -154,7 +159,7 @@ char *receive_str(int file_descriptor) {
return data;
}
bool send_data(int file_descriptor, Data *data) {
bool send_data(int file_descriptor, Data* data) {
unsigned long long data_size = data->size;
if (!send_n_data(file_descriptor, &data_size, sizeof(unsigned long long)))
return false;
@@ -164,12 +169,13 @@ bool send_data(int file_descriptor, Data *data) {
return true;
}
Data *receive_data(int file_descriptor) {
Data* receive_data(int file_descriptor) {
unsigned long long size = 0;
if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
return NULL;
void *data = malloc((size_t)size);
if (data == NULL) return NULL;
void* data = malloc((size_t)size);
if (data == NULL)
return NULL;
if (!receive_n_data(file_descriptor, data, (size_t)size)) {
free(data);
return NULL;
@@ -179,25 +185,29 @@ Data *receive_data(int file_descriptor) {
}
bool send_int(int file_descriptor, int data) {
if (!send_n_data(file_descriptor, &data, sizeof(int))) return false;
if (!send_n_data(file_descriptor, &data, sizeof(int)))
return false;
log_message(LOG_LEVEL_DEBUG, "Send Int: %d", data);
return true;
}
bool receive_int(int file_descriptor, int *data) {
if (!receive_n_data(file_descriptor, data, sizeof(int))) return false;
bool receive_int(int file_descriptor, int* data) {
if (!receive_n_data(file_descriptor, data, sizeof(int)))
return false;
log_message(LOG_LEVEL_DEBUG, "Received Int: %d", *data);
return true;
}
bool send_status(int file_descriptor, Status status) {
if (!send_n_data(file_descriptor, &status, sizeof(Status))) return false;
if (!send_n_data(file_descriptor, &status, sizeof(Status)))
return false;
log_message(LOG_LEVEL_DEBUG, "Send Status: %s", status_to_string(status));
return true;
}
bool receive_status(int file_descriptor, Status *status) {
if (!receive_n_data(file_descriptor, status, sizeof(Status))) return false;
bool receive_status(int file_descriptor, Status* status) {
if (!receive_n_data(file_descriptor, status, sizeof(Status)))
return false;
log_message(LOG_LEVEL_DEBUG, "Received Status: %s", status_to_string(*status));
return true;
}
src/shared/protocol.h
+18 -10
View File
@@ -8,22 +8,30 @@
typedef struct ssl_st SSL;
typedef int Status;
enum NET_STATUS { STATUS_OK, STATUS_ERROR, STATUS_FINISHED, STATUS_NEXT, STATUS_CHUNK, STATUS_MANIFEST, STATUS_CHECK };
enum NET_STATUS {
STATUS_OK,
STATUS_ERROR,
STATUS_FINISHED,
STATUS_NEXT,
STATUS_CHUNK,
STATUS_MANIFEST,
STATUS_CHECK
};
void io_set_fds(int read_fd, int write_fd);
void io_set_bwlimit(unsigned long long bytes_per_sec);
typedef struct ssl_st SSL;
void io_set_ssl(SSL *ssl);
bool send_n_data(int file_descriptor, void *data, size_t data_size);
bool receive_n_data(int file_descriptor, void *data, size_t data_size);
void io_set_ssl(SSL* ssl);
bool send_n_data(int file_descriptor, void* data, size_t data_size);
bool receive_n_data(int file_descriptor, void* data, size_t data_size);
bool send_str(int file_descriptor, char *data);
char *receive_str(int file_descriptor);
bool send_data(int file_descriptor, Data *data);
Data *receive_data(int file_descriptor);
bool send_str(int file_descriptor, char* data);
char* receive_str(int file_descriptor);
bool send_data(int file_descriptor, Data* data);
Data* receive_data(int file_descriptor);
bool send_int(int file_descriptor, int data);
bool receive_int(int file_descriptor, int *data);
bool receive_int(int file_descriptor, int* data);
bool send_status(int file_descriptor, Status status);
bool receive_status(int file_descriptor, Status *status);
bool receive_status(int file_descriptor, Status* status);
#endif
src/shared/queue.c
+22 -22
View File
@@ -6,14 +6,14 @@
#include "queue.h"
Queue *queue_create(int capacity, void (*destroyer)(void *item)) {
Queue *queue = (Queue *)malloc(sizeof(Queue));
Queue* queue_create(int capacity, void (*destroyer)(void* item)) {
Queue* queue = (Queue*)malloc(sizeof(Queue));
if (queue == NULL) {
perror("ERROR: Could not allocate memory for queue structure");
return NULL;
}
queue->items = malloc(capacity * sizeof(void *));
queue->items = malloc(capacity * sizeof(void*));
if (queue->items == NULL) {
free(queue);
return NULL;
@@ -32,7 +32,7 @@ Queue *queue_create(int capacity, void (*destroyer)(void *item)) {
return queue;
}
void queue_destroy(Queue *queue) {
void queue_destroy(Queue* queue) {
if (queue == NULL)
return;
@@ -46,24 +46,25 @@ void queue_destroy(Queue *queue) {
free(queue);
}
bool queue_is_empty(Queue *queue) {
bool queue_is_empty(const Queue* queue) {
if (queue == NULL)
return true;
return queue->size == 0;
}
bool queue_is_full(Queue *queue) {
bool queue_is_full(const Queue* queue) {
if (queue == NULL)
return false;
return queue->size == queue->capacity;
}
static bool queue_double_capacity(Queue *queue) {
if (queue == NULL) return false;
static bool queue_double_capacity(Queue* queue) {
if (queue == NULL)
return false;
unsigned int new_capacity = queue->capacity * 2;
if (new_capacity <= 1)
new_capacity = 100;
void **new_items = malloc(new_capacity * sizeof(void *));
void** new_items = malloc(new_capacity * sizeof(void*));
if (new_items == NULL) {
perror("ERROR: Could not allocate memory for doubling capacity of queue.");
return false;
@@ -78,10 +79,12 @@ static bool queue_double_capacity(Queue *queue) {
return true;
}
bool queue_enqueue(Queue *queue, void *item) {
if (queue == NULL || item == NULL) return false;
bool queue_enqueue(Queue* queue, void* item) {
if (queue == NULL || item == NULL)
return false;
if (queue_is_full(queue)) {
if (!queue_double_capacity(queue)) return false;
if (!queue_double_capacity(queue))
return false;
}
queue->items[queue->rear] = item;
queue->rear = (queue->rear + 1) % queue->capacity;
@@ -89,9 +92,8 @@ bool queue_enqueue(Queue *queue, void *item) {
return true;
}
bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
cnd_t *condition_not_empty,
cnd_t *condition_not_full) {
bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
cnd_t* condition_not_full) {
mtx_lock(mutex);
while (queue_is_full(queue))
cnd_wait(condition_not_full, mutex);
@@ -101,23 +103,21 @@ bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
return ok;
}
void *queue_dequeue(Queue *queue) {
void* queue_dequeue(Queue* queue) {
if (queue == NULL || queue_is_empty(queue)) {
perror("ERROR: Could not dequeue from null or empty queue.");
return NULL;
}
void *item = queue->items[queue->front];
void* item = queue->items[queue->front];
queue->items[queue->front] = NULL;
queue->front = (queue->front + 1) % queue->capacity;
queue->size--;
return item;
}
void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
cnd_t *condition_not_empty,
cnd_t *condition_not_full,
bool *other_thread_done) {
void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
cnd_t* condition_not_full, const bool* other_thread_done) {
mtx_lock(mutex);
while (queue_is_empty(queue) && !*other_thread_done)
cnd_wait(condition_not_empty, mutex);
@@ -125,7 +125,7 @@ void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
mtx_unlock(mutex);
return NULL;
}
void *item = queue_dequeue(queue);
void* item = queue_dequeue(queue);
cnd_signal(condition_not_full);
mtx_unlock(mutex);
return item;
src/shared/queue.h
+12 -15
View File
@@ -5,26 +5,23 @@
#include <threads.h>
typedef struct Queue {
void **items;
void** items;
int front;
int rear;
int size;
int capacity;
void (*item_destroyer)(void *item);
void (*item_destroyer)(void* item);
} Queue;
Queue *queue_create(int capacity, void (*destroyer)(void *item));
void queue_destroy(Queue *queue);
bool queue_is_empty(Queue *queue);
bool queue_is_full(Queue *queue);
bool queue_enqueue(Queue *queue, void *item);
bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
cnd_t *condition_not_empty,
cnd_t *condition_not_full);
void *queue_dequeue(Queue *queue);
void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
cnd_t *condition_not_empty,
cnd_t *condition_not_full,
bool *other_thread_done);
Queue* queue_create(int capacity, void (*destroyer)(void* item));
void queue_destroy(Queue* queue);
bool queue_is_empty(const Queue* queue);
bool queue_is_full(const Queue* queue);
bool queue_enqueue(Queue* queue, void* item);
bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
cnd_t* condition_not_full);
void* queue_dequeue(Queue* queue);
void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
cnd_t* condition_not_full, const bool* other_thread_done);
#endif
src/shared/transport_ssh.c
+24 -15
View File
@@ -13,36 +13,41 @@ typedef struct {
char remote_path[4096];
} RemoteDest;
static int parse_remote_dest(const char *dest, RemoteDest *r) {
const char *colon = strchr(dest, ':');
if (!colon) return -1;
static int parse_remote_dest(const char* dest, RemoteDest* r) {
const char* colon = strchr(dest, ':');
if (!colon)
return -1;
size_t remote_path_len = strlen(colon + 1);
if (remote_path_len >= sizeof(r->remote_path)) return -1;
if (remote_path_len >= sizeof(r->remote_path))
return -1;
memcpy(r->remote_path, colon + 1, remote_path_len + 1);
const char *at = memchr(dest, '@', colon - dest);
const char* at = memchr(dest, '@', colon - dest);
if (at) {
size_t user_len = at - dest;
if (user_len >= sizeof(r->user)) return -1;
if (user_len >= sizeof(r->user))
return -1;
memcpy(r->user, dest, user_len);
r->user[user_len] = '\0';
size_t host_len = colon - at - 1;
if (host_len >= sizeof(r->host)) return -1;
if (host_len >= sizeof(r->host))
return -1;
memcpy(r->host, at + 1, host_len);
r->host[host_len] = '\0';
} else {
r->user[0] = '\0';
size_t host_len = colon - dest;
if (host_len >= sizeof(r->host)) return -1;
if (host_len >= sizeof(r->host))
return -1;
memcpy(r->host, dest, host_len);
r->host[host_len] = '\0';
}
return 0;
}
Client *client_connect_ssh(char *destination, int port) {
Client* client_connect_ssh(const char* destination, int port) {
RemoteDest r;
if (parse_remote_dest(destination, &r) != 0) {
fprintf(stderr, "Invalid remote destination: %s\n", destination);
@@ -64,15 +69,18 @@ Client *client_connect_ssh(char *destination, int port) {
int exec_pipe[2];
if (pipe(exec_pipe) < 0) {
perror("pipe failed");
close(sv[0]); close(sv[1]);
close(sv[0]);
close(sv[1]);
return NULL;
}
pid_t pid = fork();
if (pid < 0) {
perror("fork failed");
close(sv[0]); close(sv[1]);
close(exec_pipe[0]); close(exec_pipe[1]);
close(sv[0]);
close(sv[1]);
close(exec_pipe[0]);
close(exec_pipe[1]);
return NULL;
}
@@ -85,7 +93,8 @@ Client *client_connect_ssh(char *destination, int port) {
dup2(sv[1], STDIN_FILENO);
if (sv[1] != STDOUT_FILENO)
dup2(sv[1], STDOUT_FILENO);
if (sv[1] > 1) close(sv[1]);
if (sv[1] > 1)
close(sv[1]);
char ssh_user[512];
if (r.user[0] != '\0')
@@ -93,7 +102,7 @@ Client *client_connect_ssh(char *destination, int port) {
else
snprintf(ssh_user, sizeof(ssh_user), "%s", r.host);
char *ssh_argv[16];
char* ssh_argv[16];
int ac = 0;
char port_str[16];
ssh_argv[ac++] = "ssh";
@@ -133,7 +142,7 @@ Client *client_connect_ssh(char *destination, int port) {
return NULL;
}
Client *client = malloc(sizeof(Client));
Client* client = malloc(sizeof(Client));
if (client == NULL) {
close(sv[0]);
waitpid(pid, NULL, 0);
src/shared/transport_ssh.h
+1 -1
View File
@@ -3,6 +3,6 @@
#include "transport_tcp.h"
Client *client_connect_ssh(char *destination, int port);
Client* client_connect_ssh(const char* destination, int port);
#endif
src/shared/transport_tcp.c
+30 -30
View File
@@ -11,8 +11,8 @@
#include <sys/wait.h>
#include <unistd.h>
Server *server_create(int port) {
Server *server = (Server *)malloc(sizeof(Server));
Server* server_create(int port) {
Server* server = (Server*)malloc(sizeof(Server));
if (server == NULL) {
perror("Could not allocate space for Server");
return NULL;
@@ -26,8 +26,7 @@ Server *server_create(int port) {
}
server->file_descriptor = file_descriptor;
int opt = 1;
if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt,
sizeof(opt))) {
if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
perror("Error setting a socket option!");
close(server->file_descriptor);
free(server);
@@ -40,8 +39,8 @@ Server *server_create(int port) {
server->address_length = sizeof(server->address);
server->ssl_ctx = NULL;
if (bind(server->file_descriptor, (struct sockaddr *)&server->address,
server->address_length) < 0) {
if (bind(server->file_descriptor, (struct sockaddr*)&server->address, server->address_length) <
0) {
perror("Could not bind server");
close(server->file_descriptor);
free(server);
@@ -51,8 +50,9 @@ Server *server_create(int port) {
return server;
}
void server_delete(Server **server) {
if (server == NULL || *server == NULL) return;
void server_delete(Server** server) {
if (server == NULL || *server == NULL)
return;
close((*server)->file_descriptor);
if ((*server)->ssl_ctx) {
SSL_CTX_free((*server)->ssl_ctx);
@@ -62,8 +62,8 @@ void server_delete(Server **server) {
*server = NULL;
}
static void accept_loop(Server *server, void (*child_fn)(int, void *),
void *child_ctx, const char *log_fmt) {
static void accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
const char* log_fmt) {
if (listen(server->file_descriptor, SOMAXCONN) < 0) {
perror("Could not listen on port!");
return;
@@ -72,8 +72,7 @@ static void accept_loop(Server *server, void (*child_fn)(int, void *),
while (1) {
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int fd = accept(server->file_descriptor, (struct sockaddr *)&client_addr,
&client_len);
int fd = accept(server->file_descriptor, (struct sockaddr*)&client_addr, &client_len);
if (fd < 0) {
perror("Could not accept the connection");
continue;
@@ -90,35 +89,35 @@ static void accept_loop(Server *server, void (*child_fn)(int, void *),
}
}
struct plain_ctx { void (*handler)(int); };
struct plain_ctx {
void (*handler)(int);
};
static void plain_child_fn(int fd, void *ctx) {
((struct plain_ctx *)ctx)->handler(fd);
static void plain_child_fn(int fd, void* ctx) {
((struct plain_ctx*)ctx)->handler(fd);
}
bool server_listen(Server *server, void (*handler)(int file_descriptor)) {
log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d",
ntohs(server->address.sin_port));
bool server_listen(Server* server, void (*handler)(int file_descriptor)) {
log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d", ntohs(server->address.sin_port));
struct plain_ctx ctx = {handler};
accept_loop(server, plain_child_fn, &ctx, "Received Connection");
return true;
}
void server_accept_loop(Server *server, void (*child_fn)(int, void *),
void *child_ctx, const char *log_fmt) {
log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d",
ntohs(server->address.sin_port));
void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
const char* log_fmt) {
log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d", ntohs(server->address.sin_port));
accept_loop(server, child_fn, child_ctx, log_fmt);
}
Client *client_create() {
Client* client_create() {
int file_descriptor = socket(AF_INET, SOCK_STREAM, 0);
if (file_descriptor < 0) {
perror("Could not create Socket!");
return NULL;
}
Client *client = (Client *)malloc(sizeof(Client));
Client* client = (Client*)malloc(sizeof(Client));
if (client == NULL) {
close(file_descriptor);
return NULL;
@@ -132,7 +131,7 @@ Client *client_create() {
return client;
}
bool client_connect(Client *client, char *host, int port) {
bool client_connect(Client* client, char* host, int port) {
client->address.sin_port = htons(port);
if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
@@ -140,15 +139,15 @@ bool client_connect(Client *client, char *host, int port) {
return false;
}
if (connect(client->file_descriptor, (struct sockaddr *)&client->address,
client->address_length) < 0) {
if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
0) {
perror("Could not connect to Server!");
return false;
}
return true;
}
void client_disconnect(Client *client) {
void client_disconnect(Client* client) {
if (client->ssl) {
SSL_shutdown(client->ssl);
SSL_free(client->ssl);
@@ -163,8 +162,9 @@ void client_disconnect(Client *client) {
}
}
void client_delete(Client *client) {
if (client == NULL) return;
void client_delete(Client* client) {
if (client == NULL)
return;
if (client->ssl_ctx) {
SSL_CTX_free(client->ssl_ctx);
client->ssl_ctx = NULL;
src/shared/transport_tcp.h
+12 -12
View File
@@ -9,7 +9,7 @@ typedef struct Server {
struct sockaddr_in address;
unsigned int address_length;
int file_descriptor;
void *ssl_ctx;
void* ssl_ctx;
} Server;
typedef struct Client {
@@ -17,18 +17,18 @@ typedef struct Client {
unsigned int address_length;
int file_descriptor;
pid_t ssh_child_pid;
void *ssl;
void *ssl_ctx;
void* ssl;
void* ssl_ctx;
} Client;
Server *server_create(int port);
bool server_listen(Server *server, void (*handler)(int file_descriptor));
void server_accept_loop(Server *server, void (*child_fn)(int, void *),
void *child_ctx, const char *log_fmt);
void server_delete(Server **server);
Client *client_create();
bool client_connect(Client *client, char *host, int port);
void client_disconnect(Client *client);
void client_delete(Client *client);
Server* server_create(int port);
bool server_listen(Server* server, void (*handler)(int file_descriptor));
void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
const char* log_fmt);
void server_delete(Server** server);
Client* client_create();
bool client_connect(Client* client, char* host, int port);
void client_disconnect(Client* client);
void client_delete(Client* client);
#endif
src/shared/transport_tls.c
+29 -30
View File
@@ -31,11 +31,10 @@ static void log_ssl_errors(void) {
}
}
static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
const char *key, const char *ca_path) {
const SSL_METHOD *method =
is_server ? TLS_server_method() : TLS_client_method();
SSL_CTX *ctx = SSL_CTX_new(method);
static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key,
const char* ca_path) {
const SSL_METHOD* method = is_server ? TLS_server_method() : TLS_client_method();
SSL_CTX* ctx = SSL_CTX_new(method);
if (!ctx) {
log_message(LOG_LEVEL_ERROR, "Unable to create SSL context");
log_ssl_errors();
@@ -58,8 +57,7 @@ static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
return NULL;
}
if (!SSL_CTX_check_private_key(ctx)) {
log_message(LOG_LEVEL_ERROR,
"Private key does not match certificate");
log_message(LOG_LEVEL_ERROR, "Private key does not match certificate");
SSL_CTX_free(ctx);
return NULL;
}
@@ -79,8 +77,8 @@ static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
return ctx;
}
static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
SSL *ssl = SSL_new(ctx);
static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) {
SSL* ssl = SSL_new(ctx);
if (!ssl) {
log_message(LOG_LEVEL_ERROR, "Failed to create SSL object");
return NULL;
@@ -93,8 +91,7 @@ static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
ret = SSL_connect(ssl);
if (ret <= 0) {
log_message(LOG_LEVEL_ERROR, "SSL %s failed",
is_server ? "accept" : "connect");
log_message(LOG_LEVEL_ERROR, "SSL %s failed", is_server ? "accept" : "connect");
log_ssl_errors();
SSL_free(ssl);
return NULL;
@@ -102,23 +99,25 @@ static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
return ssl;
}
bool server_create_tls(Server *server, const char *cert_path,
const char *key_path, const char *ca_path) {
SSL_CTX *ctx = create_ssl_ctx(true, cert_path, key_path, ca_path);
if (!ctx) return false;
bool server_create_tls(Server* server, const char* cert_path, const char* key_path,
const char* ca_path) {
SSL_CTX* ctx = create_ssl_ctx(true, cert_path, key_path, ca_path);
if (!ctx)
return false;
server->ssl_ctx = ctx;
return true;
}
struct tls_child_ctx {
void (*handler)(int);
SSL_CTX *ssl_ctx;
SSL_CTX* ssl_ctx;
};
static void tls_child_fn(int fd, void *arg) {
struct tls_child_ctx *ctx = (struct tls_child_ctx *)arg;
SSL *ssl = wrap_fd_with_ssl(fd, ctx->ssl_ctx, true);
if (!ssl) return;
static void tls_child_fn(int fd, void* arg) {
struct tls_child_ctx* ctx = (struct tls_child_ctx*)arg;
SSL* ssl = wrap_fd_with_ssl(fd, ctx->ssl_ctx, true);
if (!ssl)
return;
io_set_ssl(ssl);
ctx->handler(fd);
SSL_shutdown(ssl);
@@ -126,31 +125,31 @@ static void tls_child_fn(int fd, void *arg) {
io_set_ssl(NULL);
}
bool server_listen_tls(Server *server, void (*handler)(int file_descriptor)) {
struct tls_child_ctx ctx = {handler, (SSL_CTX *)server->ssl_ctx};
bool server_listen_tls(Server* server, void (*handler)(int file_descriptor)) {
struct tls_child_ctx ctx = {handler, (SSL_CTX*)server->ssl_ctx};
server_accept_loop(server, tls_child_fn, &ctx, "Received TLS Connection");
return true;
}
bool client_connect_tls(Client *client, char *host, int port,
const char *cert_path, const char *key_path,
const char *ca_path) {
bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
const char* key_path, const char* ca_path) {
client->address.sin_port = htons(port);
if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
perror("Could not convert host address!");
return false;
}
if (connect(client->file_descriptor, (struct sockaddr *)&client->address,
client->address_length) < 0) {
if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
0) {
perror("Could not connect to Server!");
return false;
}
SSL_CTX *ctx = create_ssl_ctx(false, cert_path, key_path, ca_path);
if (!ctx) return false;
SSL_CTX* ctx = create_ssl_ctx(false, cert_path, key_path, ca_path);
if (!ctx)
return false;
client->ssl_ctx = ctx;
SSL *ssl = wrap_fd_with_ssl(client->file_descriptor, ctx, false);
SSL* ssl = wrap_fd_with_ssl(client->file_descriptor, ctx, false);
if (!ssl) {
SSL_CTX_free(ctx);
client->ssl_ctx = NULL;
src/shared/transport_tls.h
+5 -6
View File
@@ -6,11 +6,10 @@
bool tls_global_init(void);
bool server_create_tls(Server *server, const char *cert_path,
const char *key_path, const char *ca_path);
bool server_listen_tls(Server *server, void (*handler)(int file_descriptor));
bool client_connect_tls(Client *client, char *host, int port,
const char *cert_path, const char *key_path,
const char *ca_path);
bool server_create_tls(Server* server, const char* cert_path, const char* key_path,
const char* ca_path);
bool server_listen_tls(Server* server, void (*handler)(int file_descriptor));
bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
const char* key_path, const char* ca_path);
#endif
src/shared/utils.c
+27 -23
View File
@@ -8,21 +8,25 @@
#include <sys/stat.h>
#include <unistd.h>
bool mkdir_r(char *path) {
char *path_duplicate = malloc(strlen(path) + 1);
if (!path_duplicate) return false;
bool mkdir_r(const char* path) {
char* path_duplicate = malloc(strlen(path) + 1);
if (!path_duplicate)
return false;
strcpy(path_duplicate, path);
char *path_current = (char *)malloc((strlen(path) + 2) * sizeof(char));
if (!path_current) { free(path_duplicate); return false; }
char *path_current_position = path_current;
char* path_current = (char*)malloc((strlen(path) + 2) * sizeof(char));
if (!path_current) {
free(path_duplicate);
return false;
}
char* path_current_position = path_current;
if (path[0] == '/') {
strcpy(path_current, "/");
path_current_position += 1;
} else {
path_current[0] = '\0';
}
const char *delimiter = "/";
char *part = strtok(path_duplicate, delimiter);
const char* delimiter = "/";
const char* part = strtok(path_duplicate, delimiter);
bool ok = true;
while (part != NULL) {
strcpy(path_current_position, part);
@@ -44,15 +48,15 @@ bool mkdir_r(char *path) {
return ok;
}
char *str_dup(const char *string) {
char* str_dup(const char* string) {
if (string == NULL)
return NULL;
char *new_string = (char *)malloc(strlen(string) + 1);
char* new_string = (char*)malloc(strlen(string) + 1);
strcpy(new_string, string);
return new_string;
}
bool glob_match(const char *pattern, const char *str) {
bool glob_match(const char* pattern, const char* str) {
while (*pattern) {
if (*pattern == '*') {
pattern++;
@@ -77,17 +81,16 @@ bool glob_match(const char *pattern, const char *str) {
return *str == '\0';
}
static void delete_extras_walk(const char *abs_path, const char *rel_path,
ArrayList *manifest) {
DIR *dir = opendir(abs_path);
static void delete_extras_walk(const char* abs_path, const char* rel_path, ArrayList* manifest) {
DIR* dir = opendir(abs_path);
if (!dir)
return;
struct dirent *entry;
struct dirent* entry;
while ((entry = readdir(dir)) != NULL) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue;
char *child_abs = path_cat((char *)abs_path, entry->d_name);
char *child_rel = path_cat((char *)rel_path, entry->d_name);
char* child_abs = path_cat((char*)abs_path, entry->d_name);
char* child_rel = path_cat((char*)rel_path, entry->d_name);
struct stat st;
if (stat(child_abs, &st) != 0) {
free(child_abs);
@@ -100,7 +103,7 @@ static void delete_extras_walk(const char *abs_path, const char *rel_path,
// Check if relative path is in manifest
bool found = false;
for (int i = 0; i < manifest->size; i++) {
if (strcmp((char *)manifest->items[i], child_rel) == 0) {
if (strcmp((char*)manifest->items[i], child_rel) == 0) {
found = true;
break;
}
@@ -117,26 +120,27 @@ static void delete_extras_walk(const char *abs_path, const char *rel_path,
rmdir(abs_path);
}
void delete_extras(const char *dest_root, ArrayList *manifest) {
void delete_extras(const char* dest_root, ArrayList* manifest) {
delete_extras_walk(dest_root, "", manifest);
}
char *path_cat(char *path1, char *path2) {
char* path_cat(const char* path1, char* path2) {
if (path1 == NULL || *path1 == '\0')
return str_dup(path2);
if (path2 == NULL || *path2 == '\0')
return str_dup(path1);
int path1_len = strlen(path1);
int path2_len = strlen(path2);
char *path2_pointer = path2;
char* path2_pointer = path2;
if (path1[path1_len - 1] == '/')
path1_len -= 1;
if (path2[0] == '/') {
path2_pointer += 1;
path2_len -= 1;
}
char *new_path = malloc(path1_len + path2_len + 2);
if (new_path == NULL) return NULL;
char* new_path = malloc(path1_len + path2_len + 2);
if (new_path == NULL)
return NULL;
memcpy(new_path, path1, path1_len);
new_path[path1_len] = '/';
memcpy(new_path + path1_len + 1, path2_pointer, path2_len);
src/shared/utils.h
+5 -5
View File
@@ -4,10 +4,10 @@
#include "array_list.h"
#include <stdbool.h>
bool mkdir_r(char *path);
char *str_dup(const char *string);
char *path_cat(char *path1, char *path2);
bool glob_match(const char *pattern, const char *str);
void delete_extras(const char *dest_root, ArrayList *manifest);
bool mkdir_r(const char* path);
char* str_dup(const char* string);
char* path_cat(const char* path1, char* path2);
bool glob_match(const char* pattern, const char* str);
void delete_extras(const char* dest_root, ArrayList* manifest);
#endif
tests/test_array_list.c
+11 -11
View File
@@ -4,28 +4,28 @@
#include <stdlib.h>
static int destroyer_calls = 0;
static void test_destroyer(void *item) {
static void test_destroyer(void* item) {
destroyer_calls++;
free(item);
}
void test_array_list() {
ArrayList *list = array_list_create(free);
ArrayList* list = array_list_create(free);
EXPECT_NOT_NULL(list);
EXPECT_EQ_INT(list->size, 0);
EXPECT_EQ_INT(list->capacity, 100);
// Test adding
int *val1 = malloc(sizeof(int));
int* val1 = malloc(sizeof(int));
*val1 = 42;
array_list_add(list, val1);
EXPECT_EQ_INT(list->size, 1);
EXPECT_EQ_INT(*(int *)list->items[0], 42);
EXPECT_EQ_INT(*(int*)list->items[0], 42);
// Test extending capacity
// Initial capacity is 100. Let's add 105 elements.
for (int i = 0; i < 105; i++) {
int *val = malloc(sizeof(int));
int* val = malloc(sizeof(int));
*val = i;
array_list_add(list, val);
}
@@ -33,15 +33,15 @@ void test_array_list() {
EXPECT_EQ_INT(list->capacity, 200); // 100 * 2
// Verify contents
EXPECT_EQ_INT(*(int *)list->items[0], 42);
EXPECT_EQ_INT(*(int *)list->items[1], 0);
EXPECT_EQ_INT(*(int *)list->items[105], 104);
EXPECT_EQ_INT(*(int*)list->items[0], 42);
EXPECT_EQ_INT(*(int*)list->items[1], 0);
EXPECT_EQ_INT(*(int*)list->items[105], 104);
// Test array conversion
void **arr = array_list_to_array(list);
void** arr = array_list_to_array(list);
EXPECT_NOT_NULL(arr);
EXPECT_EQ_INT(*(int *)arr[0], 42);
EXPECT_EQ_INT(*(int *)arr[105], 104);
EXPECT_EQ_INT(*(int*)arr[0], 42);
EXPECT_EQ_INT(*(int*)arr[105], 104);
free(arr);
// Delete list, verifying the destroyer is called 106 times
tests/test_chunk.c
+13 -13
View File
@@ -7,13 +7,13 @@
#include <unistd.h>
static void test_file_operations() {
char *test_path = "temp_file_test.txt";
char *test_content = "Hello, Chunk System!";
char* test_path = "temp_file_test.txt";
char* test_content = "Hello, Chunk System!";
unsigned long long test_len = strlen(test_content);
to_disk(test_path, test_content, test_len);
File *f = file_create(test_path);
File* f = file_create(test_path);
EXPECT_NOT_NULL(f);
EXPECT_EQ_STR(f->path, test_path);
EXPECT_NOT_NULL(f->data);
@@ -35,12 +35,12 @@ static void test_file_operations() {
}
static void test_chunk_operations() {
char *path1 = "temp_chunk_1.txt";
char *content1 = "chunk item 1";
char* path1 = "temp_chunk_1.txt";
char* content1 = "chunk item 1";
unsigned long long len1 = strlen(content1);
char *path2 = "temp_chunk_2.txt";
char *content2 = "chunk item number 2";
char* path2 = "temp_chunk_2.txt";
char* content2 = "chunk item number 2";
unsigned long long len2 = strlen(content2);
to_disk(path1, content1, len1);
@@ -50,13 +50,13 @@ static void test_chunk_operations() {
stat(path1, &st1);
stat(path2, &st2);
File *f1 = file_create(path1);
File* f1 = file_create(path1);
f1->data->size = st1.st_size;
File *f2 = file_create(path2);
File* f2 = file_create(path2);
f2->data->size = st2.st_size;
File *files[2] = {f1, f2};
Chunk *chunk = chunk_create(files, 2);
File* files[2] = {f1, f2};
Chunk* chunk = chunk_create(files, 2);
EXPECT_NOT_NULL(chunk);
EXPECT_EQ_INT(chunk->element_count, 2);
EXPECT_NOT_NULL(chunk->items[0]);
@@ -67,10 +67,10 @@ static void test_chunk_operations() {
file_load_data(f2);
// Test chunk_serialize / chunk_deserialize round-trip
Data *serialized = chunk_serialize(chunk, false);
Data* serialized = chunk_serialize(chunk, false);
EXPECT_NOT_NULL(serialized);
Chunk *deserialized = chunk_deserialize(serialized, false);
Chunk* deserialized = chunk_deserialize(serialized, false);
EXPECT_NOT_NULL(deserialized);
EXPECT_EQ_INT(deserialized->element_count, 2);
EXPECT_EQ_STR(deserialized->items[0]->path, path1);
tests/test_compression.c
+20 -20
View File
@@ -9,18 +9,18 @@
#include <unistd.h>
static void test_data_compress_decompress_roundtrip() {
char original[] = "Hello, World! This is test data for compression round-trip!";
const char original[] = "Hello, World! This is test data for compression round-trip!";
size_t len = strlen(original);
char *buf = malloc(len);
char* buf = malloc(len);
memcpy(buf, original, len);
Data *original_data = data_create(buf, len);
Data* original_data = data_create(buf, len);
EXPECT_NOT_NULL(original_data);
Data *compressed = data_compress(original_data, 3);
Data* compressed = data_compress(original_data, 3);
EXPECT_NOT_NULL(compressed);
Data *decompressed = data_decompress(compressed);
Data* decompressed = data_decompress(compressed);
EXPECT_NOT_NULL(decompressed);
EXPECT_EQ_INT((int)decompressed->size, (int)len);
EXPECT_EQ_INT(memcmp(decompressed->data, original, len), 0);
@@ -32,18 +32,18 @@ static void test_data_compress_decompress_roundtrip() {
static void test_data_compress_decompress_large() {
size_t size = 1024 * 10;
char *original = malloc(size);
char* original = malloc(size);
EXPECT_NOT_NULL(original);
for (size_t i = 0; i < size; i++)
original[i] = (char)(i % 256);
Data *original_data = data_create(original, size);
Data* original_data = data_create(original, size);
EXPECT_NOT_NULL(original_data);
Data *compressed = data_compress(original_data, 1);
Data* compressed = data_compress(original_data, 1);
EXPECT_NOT_NULL(compressed);
Data *decompressed = data_decompress(compressed);
Data* decompressed = data_decompress(compressed);
EXPECT_NOT_NULL(decompressed);
EXPECT_EQ_INT((int)decompressed->size, (int)size);
EXPECT_EQ_INT(memcmp(decompressed->data, original, size), 0);
@@ -54,12 +54,12 @@ static void test_data_compress_decompress_large() {
}
static void test_chunk_compress_decompress_roundtrip() {
char *path1 = "temp_comp_test_1.txt";
char *content1 = "chunk compression test file 1";
char* path1 = "temp_comp_test_1.txt";
char* content1 = "chunk compression test file 1";
unsigned long long len1 = strlen(content1);
char *path2 = "temp_comp_test_2.txt";
char *content2 = "chunk compression test file 2 with more data";
char* path2 = "temp_comp_test_2.txt";
char* content2 = "chunk compression test file 2 with more data";
unsigned long long len2 = strlen(content2);
to_disk(path1, content1, len1);
@@ -69,9 +69,9 @@ static void test_chunk_compress_decompress_roundtrip() {
EXPECT_EQ_INT(stat(path1, &st1), 0);
EXPECT_EQ_INT(stat(path2, &st2), 0);
File *f1 = file_create(path1);
File* f1 = file_create(path1);
f1->data->size = st1.st_size;
File *f2 = file_create(path2);
File* f2 = file_create(path2);
f2->data->size = st2.st_size;
EXPECT_NOT_NULL(f1);
EXPECT_NOT_NULL(f2);
@@ -79,17 +79,17 @@ static void test_chunk_compress_decompress_roundtrip() {
file_load_data(f1);
file_load_data(f2);
File *files[2] = {f1, f2};
Chunk *chunk = chunk_create(files, 2);
File* files[2] = {f1, f2};
Chunk* chunk = chunk_create(files, 2);
EXPECT_NOT_NULL(chunk);
Data *compressed = chunk_compress(chunk, 3, false);
Data* compressed = chunk_compress(chunk, 3, false);
EXPECT_NOT_NULL(compressed);
Data *decompressed_data = data_decompress(compressed);
Data* decompressed_data = data_decompress(compressed);
EXPECT_NOT_NULL(decompressed_data);
Chunk *decompressed_chunk = chunk_deserialize(decompressed_data, false);
Chunk* decompressed_chunk = chunk_deserialize(decompressed_data, false);
EXPECT_NOT_NULL(decompressed_chunk);
EXPECT_EQ_INT(decompressed_chunk->element_count, 2);
tests/test_config.c
+17 -17
View File
@@ -7,8 +7,8 @@
#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, false, false, 1, false, 0);
Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/dst"), true, true, false,
false, false, 1, false, 0);
EXPECT_NOT_NULL(cfg);
EXPECT_EQ_STR(cfg->version, "1.0");
EXPECT_EQ_STR(cfg->send_directory, "/src");
@@ -23,8 +23,8 @@ static void test_config_lifecycle() {
}
static void test_config_ssh_dest() {
Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("user@host:/dst"),
true, false, false, false, false, 1, false, 0);
Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("user@host:/dst"), true,
false, false, false, false, 1, false, 0);
EXPECT_NOT_NULL(cfg);
EXPECT_EQ_INT(cfg->transport, TRANSPORT_TCP);
EXPECT_NULL(cfg->ssh_destination);
@@ -38,8 +38,8 @@ static void test_config_ssh_dest() {
}
static void test_config_ssh_dest_local_path() {
Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/local/path"),
true, false, false, false, false, 1, false, 0);
Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("/local/path"), true, false,
false, false, false, 1, false, 0);
config_parse_ssh_dest(cfg);
EXPECT_EQ_INT(cfg->transport, TRANSPORT_TCP);
EXPECT_NULL(cfg->ssh_destination);
@@ -48,8 +48,8 @@ static void test_config_ssh_dest_local_path() {
}
static void test_config_ssh_dest_no_user() {
Config *cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("host:/remote"),
true, false, false, false, false, 1, false, 0);
Config* cfg = config_create(str_dup("1.0"), str_dup("/src"), str_dup("host:/remote"), true, false,
false, false, false, 1, false, 0);
config_parse_ssh_dest(cfg);
EXPECT_EQ_INT(cfg->transport, TRANSPORT_SSH);
EXPECT_EQ_STR(cfg->ssh_destination, "host:/remote");
@@ -58,12 +58,12 @@ static void test_config_ssh_dest_no_user() {
}
static void test_pipeline_sender_lifecycle() {
Config *cfg = config_create(str_dup("2.0"), str_dup("/src2"),
str_dup("/dst2"), false, false, true, true, false, 1, false, 0);
Queue *q1 = queue_create(5, NULL);
Queue *q2 = queue_create(15, NULL);
Config* cfg = config_create(str_dup("2.0"), str_dup("/src2"), str_dup("/dst2"), false, false,
true, true, false, 1, false, 0);
Queue* q1 = queue_create(5, NULL);
Queue* q2 = queue_create(15, NULL);
PipelineContextSender *pcs = pipeline_context_sender_create(cfg, q1, q2);
PipelineContextSender* pcs = pipeline_context_sender_create(cfg, q1, q2);
EXPECT_NOT_NULL(pcs);
EXPECT_EQ_STR(pcs->config->version, "2.0");
EXPECT_EQ_INT(pcs->queue_scanner->capacity, 5);
@@ -75,11 +75,11 @@ static void test_pipeline_sender_lifecycle() {
}
static void test_pipeline_receiver_lifecycle() {
Config *cfg = config_create(str_dup("3.0"), str_dup("/src3"),
str_dup("/dst3"), true, true, true, true, false, 1, false, 0);
Queue *q = queue_create(20, NULL);
Config* cfg = config_create(str_dup("3.0"), str_dup("/src3"), str_dup("/dst3"), true, true, true,
true, false, 1, false, 0);
Queue* q = queue_create(20, NULL);
PipelineContextReceiver *pcr = pipeline_context_receiver_create(cfg, q, 42);
PipelineContextReceiver* pcr = pipeline_context_receiver_create(cfg, q, 42);
EXPECT_NOT_NULL(pcr);
EXPECT_EQ_STR(pcr->config->version, "3.0");
EXPECT_EQ_INT(pcr->queue->capacity, 20);
tests/test_queue.c
+35 -36
View File
@@ -7,12 +7,12 @@
#include <stdio.h>
static void test_queue_basic() {
Queue *q = queue_create(10, NULL);
Queue* q = queue_create(10, NULL);
EXPECT_NOT_NULL(q);
EXPECT_TRUE(queue_is_empty(q));
EXPECT_FALSE(queue_is_full(q));
int *vals[5];
int* vals[5];
for (int i = 0; i < 5; i++) {
vals[i] = malloc(sizeof(int));
*vals[i] = (i + 1) * 10;
@@ -23,19 +23,19 @@ static void test_queue_basic() {
EXPECT_FALSE(queue_is_full(q));
EXPECT_EQ_INT(q->size, 5);
int *v1 = (int *)queue_dequeue(q);
int* v1 = (int*)queue_dequeue(q);
EXPECT_NOT_NULL(v1);
EXPECT_EQ_INT(*v1, 10);
free(v1);
int *v2 = (int *)queue_dequeue(q);
int* v2 = (int*)queue_dequeue(q);
EXPECT_NOT_NULL(v2);
EXPECT_EQ_INT(*v2, 20);
free(v2);
EXPECT_EQ_INT(q->size, 3);
int *vals2[3];
int* vals2[3];
for (int i = 0; i < 3; i++) {
vals2[i] = malloc(sizeof(int));
*vals2[i] = (i + 6) * 10;
@@ -44,9 +44,9 @@ static void test_queue_basic() {
EXPECT_EQ_INT(q->size, 6);
int expected_vals[] = {30, 40, 50, 60, 70, 80};
const int expected_vals[] = {30, 40, 50, 60, 70, 80};
for (int i = 0; i < 6; i++) {
int *v = (int *)queue_dequeue(q);
int* v = (int*)queue_dequeue(q);
EXPECT_NOT_NULL(v);
EXPECT_EQ_INT(*v, expected_vals[i]);
free(v);
@@ -57,7 +57,7 @@ static void test_queue_basic() {
}
static void test_queue_resize() {
Queue *q = queue_create(3, NULL);
Queue* q = queue_create(3, NULL);
EXPECT_NOT_NULL(q);
EXPECT_EQ_INT(q->capacity, 3);
@@ -69,34 +69,34 @@ static void test_queue_resize() {
EXPECT_TRUE(queue_is_full(q));
int *v1 = (int *)queue_dequeue(q);
const int* v1 = (const int*)queue_dequeue(q);
EXPECT_NOT_NULL(v1);
EXPECT_EQ_INT(*v1, 1);
// Now front = 1, rear = 0, size = 2 (wrapped state)
queue_enqueue(q, &d);
queue_enqueue(q, &d);
EXPECT_TRUE(queue_is_full(q));
// This enqueue triggers capacity doubling
queue_enqueue(q, &e);
queue_enqueue(q, &e);
EXPECT_FALSE(queue_is_full(q));
EXPECT_EQ_INT(q->capacity, 6);
EXPECT_EQ_INT(q->size, 4);
// Dequeue all and check order: B, C, D, E
int *v2 = (int *)queue_dequeue(q);
const int* v2 = (const int*)queue_dequeue(q);
EXPECT_NOT_NULL(v2);
EXPECT_EQ_INT(*v2, 2);
int *v3 = (int *)queue_dequeue(q);
const int* v3 = (const int*)queue_dequeue(q);
EXPECT_NOT_NULL(v3);
EXPECT_EQ_INT(*v3, 3);
int *v4 = (int *)queue_dequeue(q);
const int* v4 = (const int*)queue_dequeue(q);
EXPECT_NOT_NULL(v4);
EXPECT_EQ_INT(*v4, 4);
int *v5 = (int *)queue_dequeue(q);
const int* v5 = (const int*)queue_dequeue(q);
EXPECT_NOT_NULL(v5);
EXPECT_EQ_INT(*v5, 5);
@@ -105,23 +105,23 @@ static void test_queue_resize() {
}
static int destroyer_calls = 0;
static void my_destroyer(void *item) {
static void my_destroyer(void* item) {
destroyer_calls++;
free(item);
}
static void test_queue_destroyer() {
destroyer_calls = 0;
Queue *q = queue_create(5, my_destroyer);
Queue* q = queue_create(5, my_destroyer);
EXPECT_NOT_NULL(q);
for (int i = 0; i < 3; i++) {
int *val = malloc(sizeof(int));
int* val = malloc(sizeof(int));
*val = i;
queue_enqueue(q, val);
}
int *v = (int *)queue_dequeue(q);
int* v = (int*)queue_dequeue(q);
EXPECT_NOT_NULL(v);
EXPECT_EQ_INT(*v, 0);
free(v);
@@ -131,18 +131,19 @@ static void test_queue_destroyer() {
}
typedef struct {
Queue *q;
mtx_t *mutex;
cnd_t *cnd_empty;
cnd_t *cnd_full;
Queue* q;
mtx_t* mutex;
cnd_t* cnd_empty;
cnd_t* cnd_full;
bool done;
int sum;
} ThreadContext;
static int consumer_func(void *arg) {
ThreadContext *ctx = (ThreadContext *)arg;
static int consumer_func(void* arg) {
ThreadContext* ctx = (ThreadContext*)arg;
while (true) {
int *val = (int *)queue_dequeue_multithreaded(ctx->q, ctx->mutex, ctx->cnd_empty, ctx->cnd_full, &ctx->done);
int* val = (int*)queue_dequeue_multithreaded(ctx->q, ctx->mutex, ctx->cnd_empty, ctx->cnd_full,
&ctx->done);
if (val == NULL) {
break;
}
@@ -153,7 +154,7 @@ static int consumer_func(void *arg) {
}
static void test_queue_multithreaded() {
Queue *q = queue_create(2, NULL);
Queue* q = queue_create(2, NULL);
mtx_t mutex;
cnd_t cnd_empty;
cnd_t cnd_full;
@@ -162,21 +163,19 @@ static void test_queue_multithreaded() {
cnd_init(&cnd_empty);
cnd_init(&cnd_full);
ThreadContext ctx = {
.q = q,
.mutex = &mutex,
.cnd_empty = &cnd_empty,
.cnd_full = &cnd_full,
.done = false,
.sum = 0
};
ThreadContext ctx = {.q = q,
.mutex = &mutex,
.cnd_empty = &cnd_empty,
.cnd_full = &cnd_full,
.done = false,
.sum = 0};
thrd_t consumer;
int res = thrd_create(&consumer, consumer_func, &ctx);
EXPECT_EQ_INT(res, thrd_success);
for (int i = 1; i <= 100; i++) {
int *val = malloc(sizeof(int));
int* val = malloc(sizeof(int));
*val = i;
queue_enqueue_multithreaded(q, val, &mutex, &cnd_empty, &cnd_full);
}
tests/test_scanner.c
+34 -28
View File
@@ -6,27 +6,28 @@
#include <sys/stat.h>
#include <unistd.h>
static void create_test_file(const char *path, const char *content) {
static void create_test_file(const char* path, const char* content) {
(void)to_disk(path, content, strlen(content));
}
static void test_scanner_single_file() {
const char *dir = "test_scan_dir_single";
const char *file1 = "test_scan_dir_single/file1.txt";
const char *content1 = "hello scanner";
const char* dir = "test_scan_dir_single";
const char* file1 = "test_scan_dir_single/file1.txt";
const char* content1 = "hello scanner";
mkdir(dir, 0755);
create_test_file(file1, content1);
DirectoryScanner *scanner = directory_scanner_create((char *)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
DirectoryScanner* scanner =
directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
EXPECT_NOT_NULL(scanner);
Chunk *chunk = directory_scanner_next(scanner);
Chunk* chunk = directory_scanner_next(scanner);
EXPECT_NOT_NULL(chunk);
EXPECT_EQ_INT(chunk->element_count, 1);
EXPECT_EQ_STR(chunk->items[0]->path, file1);
Chunk *next = directory_scanner_next(scanner);
const Chunk* next = directory_scanner_next(scanner);
EXPECT_NULL(next);
chunk_destroy(chunk);
@@ -36,35 +37,38 @@ static void test_scanner_single_file() {
}
static void test_scanner_multiple_files() {
const char *dir = "test_scan_dir_multi";
const char *file1 = "test_scan_dir_multi/a.txt";
const char *file2 = "test_scan_dir_multi/b.txt";
const char *content1 = "alpha";
const char *content2 = "beta";
const char* dir = "test_scan_dir_multi";
const char* file1 = "test_scan_dir_multi/a.txt";
const char* file2 = "test_scan_dir_multi/b.txt";
const char* content1 = "alpha";
const char* content2 = "beta";
mkdir(dir, 0755);
create_test_file(file1, content1);
create_test_file(file2, content2);
DirectoryScanner *scanner = directory_scanner_create((char *)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
DirectoryScanner* scanner =
directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
EXPECT_NOT_NULL(scanner);
Chunk *chunk = directory_scanner_next(scanner);
const Chunk* chunk = directory_scanner_next(scanner);
EXPECT_NOT_NULL(chunk);
EXPECT_EQ_INT(chunk->element_count, 2);
int found1 = 0, found2 = 0;
for (int i = 0; i < chunk->element_count; i++) {
if (strcmp(chunk->items[i]->path, file1) == 0) found1 = 1;
if (strcmp(chunk->items[i]->path, file2) == 0) found2 = 1;
if (strcmp(chunk->items[i]->path, file1) == 0)
found1 = 1;
if (strcmp(chunk->items[i]->path, file2) == 0)
found2 = 1;
}
EXPECT_TRUE(found1);
EXPECT_TRUE(found2);
Chunk *next = directory_scanner_next(scanner);
const Chunk* next = directory_scanner_next(scanner);
EXPECT_NULL(next);
chunk_destroy(chunk);
chunk_destroy((void*)chunk);
directory_scanner_destroy(scanner);
unlink(file1);
unlink(file2);
@@ -72,22 +76,23 @@ static void test_scanner_multiple_files() {
}
static void test_scanner_subdirectory() {
const char *root = "test_scan_sub";
const char *sub = "test_scan_sub/sub";
const char *root_file = "test_scan_sub/root.txt";
const char *sub_file = "test_scan_sub/sub/sub_file.txt";
const char *content = "nested content";
const char* root = "test_scan_sub";
const char* sub = "test_scan_sub/sub";
const char* root_file = "test_scan_sub/root.txt";
const char* sub_file = "test_scan_sub/sub/sub_file.txt";
const char* content = "nested content";
mkdir(root, 0755);
mkdir(sub, 0755);
create_test_file(root_file, content);
create_test_file(sub_file, content);
DirectoryScanner *scanner = directory_scanner_create((char *)root, false, 0, NULL, 0, NULL, 0, 0, 0);
DirectoryScanner* scanner =
directory_scanner_create((char*)root, false, 0, NULL, 0, NULL, 0, 0, 0);
EXPECT_NOT_NULL(scanner);
int total_files = 0;
Chunk *chunk;
Chunk* chunk;
while ((chunk = directory_scanner_next(scanner)) != NULL) {
total_files += chunk->element_count;
chunk_destroy(chunk);
@@ -102,14 +107,15 @@ static void test_scanner_subdirectory() {
}
static void test_scanner_empty_directory() {
const char *dir = "test_scan_empty";
const char* dir = "test_scan_empty";
mkdir(dir, 0755);
DirectoryScanner *scanner = directory_scanner_create((char *)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
DirectoryScanner* scanner =
directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
EXPECT_NOT_NULL(scanner);
Chunk *chunk = directory_scanner_next(scanner);
const Chunk* chunk = directory_scanner_next(scanner);
EXPECT_NULL(chunk);
directory_scanner_destroy(scanner);
tests/test_shared_utils.c
+21 -21
View File
@@ -6,56 +6,56 @@
void test_shared_utils() {
// Test str_dup
char *dup_null = str_dup(NULL);
const char* dup_null = str_dup(NULL);
EXPECT_NULL(dup_null);
char *dup_empty = str_dup("");
char* dup_empty = str_dup("");
EXPECT_NOT_NULL(dup_empty);
EXPECT_EQ_STR(dup_empty, "");
free(dup_empty);
char *dup_normal = str_dup("hello world");
char* dup_normal = str_dup("hello world");
EXPECT_NOT_NULL(dup_normal);
EXPECT_EQ_STR(dup_normal, "hello world");
free(dup_normal);
// Test path_cat
char *cat1 = path_cat("/foo", "/bar");
char* cat1 = path_cat("/foo", "/bar");
EXPECT_NOT_NULL(cat1);
EXPECT_EQ_STR(cat1, "/foo/bar");
free(cat1);
char *cat2 = path_cat("/foo/", "/bar");
char* cat2 = path_cat("/foo/", "/bar");
EXPECT_NOT_NULL(cat2);
EXPECT_EQ_STR(cat2, "/foo/bar");
free(cat2);
char *cat3 = path_cat("/foo", "bar");
char* cat3 = path_cat("/foo", "bar");
EXPECT_NOT_NULL(cat3);
EXPECT_EQ_STR(cat3, "/foo/bar");
free(cat3);
char *cat4 = path_cat("/foo/", "bar");
char* cat4 = path_cat("/foo/", "bar");
EXPECT_NOT_NULL(cat4);
EXPECT_EQ_STR(cat4, "/foo/bar");
free(cat4);
char *cat_empty1 = path_cat("", "/bar");
char* cat_empty1 = path_cat("", "/bar");
EXPECT_NOT_NULL(cat_empty1);
EXPECT_EQ_STR(cat_empty1, "/bar");
free(cat_empty1);
char *cat_empty2 = path_cat("/foo", "");
char* cat_empty2 = path_cat("/foo", "");
EXPECT_NOT_NULL(cat_empty2);
EXPECT_EQ_STR(cat_empty2, "/foo");
free(cat_empty2);
char *cat_null1 = path_cat(NULL, "/bar");
char* cat_null1 = path_cat(NULL, "/bar");
EXPECT_NOT_NULL(cat_null1);
EXPECT_EQ_STR(cat_null1, "/bar");
free(cat_null1);
char *cat_null2 = path_cat("/foo", NULL);
char* cat_null2 = path_cat("/foo", NULL);
EXPECT_NOT_NULL(cat_null2);
EXPECT_EQ_STR(cat_null2, "/foo");
free(cat_null2);
tests/test_utils.h
+71 -65
View File
@@ -11,84 +11,90 @@ extern int tests_failed;
extern bool current_test_failed;
// Helper to run a test function
#define RUN_TEST(test_func) \
do { \
printf("Running %s...\n", #test_func); \
tests_run++; \
current_test_failed = false; \
test_func(); \
if (current_test_failed) { \
tests_failed++; \
printf(" \033[1;31m[FAILED]\033[0m %s\n", #test_func); \
} else { \
printf(" \033[1;32m[PASSED]\033[0m %s\n", #test_func); \
} \
#define RUN_TEST(test_func) \
do { \
printf("Running %s...\n", #test_func); \
tests_run++; \
current_test_failed = false; \
test_func(); \
if (current_test_failed) { \
tests_failed++; \
printf(" \033[1;31m[FAILED]\033[0m %s\n", #test_func); \
} else { \
printf(" \033[1;32m[PASSED]\033[0m %s\n", #test_func); \
} \
} while (0)
// Assertion macros
#define EXPECT_TRUE(condition) \
do { \
if (!(condition)) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is false\n", __FILE__, __LINE__, #condition); \
current_test_failed = true; \
return; \
} \
#define EXPECT_TRUE(condition) \
do { \
if (!(condition)) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is false\n", __FILE__, \
__LINE__, #condition); \
current_test_failed = true; \
return; \
} \
} while (0)
#define EXPECT_FALSE(condition) \
do { \
if (condition) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is true\n", __FILE__, __LINE__, #condition); \
current_test_failed = true; \
return; \
} \
#define EXPECT_FALSE(condition) \
do { \
if (condition) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Assertion failed: %s is true\n", __FILE__, \
__LINE__, #condition); \
current_test_failed = true; \
return; \
} \
} while (0)
#define EXPECT_EQ_INT(actual, expected) \
do { \
int act = (actual); \
int exp = (expected); \
if (act != exp) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected %d, got %d\n", __FILE__, __LINE__, exp, act); \
current_test_failed = true; \
return; \
} \
#define EXPECT_EQ_INT(actual, expected) \
do { \
int act = (actual); \
int exp = (expected); \
if (act != exp) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected %d, got %d\n", __FILE__, __LINE__, exp, \
act); \
current_test_failed = true; \
return; \
} \
} while (0)
#define EXPECT_EQ_STR(actual, expected) \
do { \
const char *act = (actual); \
const char *exp = (expected); \
if (act == NULL || exp == NULL) { \
if (act != exp) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected %s, got %s\n", __FILE__, __LINE__, \
exp ? exp : "NULL", act ? act : "NULL"); \
current_test_failed = true; \
return; \
} \
} else if (strcmp(act, exp) != 0) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected \"%s\", got \"%s\"\n", __FILE__, __LINE__, exp, act); \
current_test_failed = true; \
return; \
} \
#define EXPECT_EQ_STR(actual, expected) \
do { \
const char* act = (actual); \
const char* exp = (expected); \
if (act == NULL || exp == NULL) { \
if (act != exp) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected %s, got %s\n", __FILE__, __LINE__, \
exp ? exp : "NULL", act ? act : "NULL"); \
current_test_failed = true; \
return; \
} \
} else if (strcmp(act, exp) != 0) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected \"%s\", got \"%s\"\n", __FILE__, \
__LINE__, exp, act); \
current_test_failed = true; \
return; \
} \
} while (0)
#define EXPECT_NOT_NULL(ptr) \
do { \
if ((ptr) == NULL) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected non-null pointer, got NULL\n", __FILE__, __LINE__); \
current_test_failed = true; \
return; \
} \
#define EXPECT_NOT_NULL(ptr) \
do { \
if ((ptr) == NULL) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected non-null pointer, got NULL\n", __FILE__, \
__LINE__); \
current_test_failed = true; \
return; \
} \
} while (0)
#define EXPECT_NULL(ptr) \
do { \
if ((ptr) != NULL) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected NULL, got %p\n", __FILE__, __LINE__, (void*)(ptr)); \
current_test_failed = true; \
return; \
} \
#define EXPECT_NULL(ptr) \
do { \
if ((ptr) != NULL) { \
printf(" \033[1;31m[FAIL]\033[0m %s:%d: Expected NULL, got %p\n", __FILE__, __LINE__, \
(void*)(ptr)); \
current_test_failed = true; \
return; \
} \
} while (0)
#endif