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

feat: implement chunk serialization protocol with -s flag

Browse Source 
- Extract chunk_serialize/chunk_deserialize from chunk_compress/chunk_decompress
- Add STATUS_CHUNK to wire protocol for chunk-mode transfers
- Client: -s sends chunk via STATUS_CHUNK (serialized or compressed+serialized)
- Server: handle STATUS_CHUNK in both single-threaded and multithreaded paths
- Fix memory leak in receive_file_receive (free->data_destroy)
- Remove dead declarations: file_receive_from_buffer, file_receive_decompress,
  file_compress, chunk_data_to_disk, unused #defines
This commit is contained in:
TapTap
2026-07-04 21:38:46 +02:00
parent e0f64e8d43
commit c4aeed9f4d
8 changed files with 188 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/shared/chunk.c
+110 -106
View File
@@ -4,7 +4,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zstd.h>
#include "chunk.h"
#include "array_list.h"
@@ -99,40 +98,129 @@ Data *chunk_format(Chunk *chunk) {
return chunk_data_create(data, buffer_size);
}
Data *chunk_compress(Chunk *chunk, int compression_level) {
log_message(LOG_LEVEL_DEBUG, "Starting to gather data for chunk compression");
Data *chunk_serialize(Chunk *chunk) {
unsigned long long data_size = 0;
for (int i = 0; i < chunk->element_count; i++) {
data_size += sizeof(unsigned long long);
data_size += sizeof(size_t);
data_size += strlen(chunk->items[i]->path);
data_size += sizeof(unsigned long long);
data_size += sizeof(size_t);
data_size += chunk->items[i]->stats.st_size;
}
Data *data = data_create_empty(data_size);
if (data == NULL) {
log_message(LOG_LEVEL_ERROR,
"Could not allocate memory for chunk compression");
"Could not allocate memory for chunk serialization");
exit(EXIT_FAILURE);
}
char *data_pointer = data->data;
for (int i = 0; i < chunk->element_count; i++) {
// path length
size_t path_len = strlen(chunk->items[i]->path);
memcpy(data_pointer, &path_len, sizeof(size_t));
data_pointer += sizeof(size_t);
memcpy(data_pointer, chunk->items[i]->path, path_len);
data_pointer += path_len;
// file data
unsigned long long data_size = chunk->items[i]->stats.st_size;
memcpy(data_pointer, &data_size, sizeof(size_t));
size_t file_data_size = chunk->items[i]->stats.st_size;
memcpy(data_pointer, &file_data_size, sizeof(size_t));
data_pointer += sizeof(size_t);
memcpy(data_pointer, chunk->items[i]->data->data, data_size);
data_pointer += data_size;
memcpy(data_pointer, chunk->items[i]->data->data, file_data_size);
data_pointer += file_data_size;
}
return data;
}
Chunk *chunk_deserialize(Data *data) {
ArrayList *files = array_list_create(file_destroy);
char *data_pointer = data->data;
size_t remaining_size = data->size;
while (remaining_size > 0) {
if (remaining_size < sizeof(size_t)) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path length");
array_list_delete(files);
return NULL;
}
size_t path_len = *(size_t *)data_pointer;
data_pointer += sizeof(size_t);
remaining_size -= sizeof(size_t);
if (remaining_size < path_len) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path");
array_list_delete(files);
return NULL;
}
char *path = malloc(path_len + 1);
if (path == NULL) {
perror("Could not allocate memory for file path");
array_list_delete(files);
return NULL;
}
memcpy(path, data_pointer, path_len);
path[path_len] = '\0';
data_pointer += path_len;
remaining_size -= path_len;
if (remaining_size < sizeof(size_t)) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for data size");
free(path);
array_list_delete(files);
return NULL;
}
size_t file_data_size = *(size_t *)data_pointer;
data_pointer += sizeof(size_t);
remaining_size -= sizeof(size_t);
if (remaining_size < file_data_size) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for file content");
free(path);
array_list_delete(files);
return NULL;
}
struct stat st = {0};
st.st_size = file_data_size;
File *file = file_create(path, &st);
if (file == NULL) {
free(path);
array_list_delete(files);
return NULL;
}
void *file_data = malloc(file_data_size);
if (file_data == NULL) {
perror("Could not allocate memory for file data");
free(path);
array_list_delete(files);
return NULL;
}
memcpy(file_data, data_pointer, file_data_size);
file->data = data_create(file_data, file_data_size);
data_pointer += file_data_size;
remaining_size -= file_data_size;
array_list_add(files, file);
free(path);
}
log_message(LOG_LEVEL_DEBUG, "Chunk succesfully compressed");
Data *compressed = data_compress(data, compression_level);
data_destroy(data);
File **file_array = (File **)array_list_to_array(files);
Chunk *chunk = chunk_create(file_array, files->size);
free(file_array);
files->item_destroyer = NULL;
array_list_delete(files);
return chunk;
}
Data *chunk_compress(Chunk *chunk, int compression_level) {
log_message(LOG_LEVEL_DEBUG, "Starting to compress chunk");
Data *serialized = chunk_serialize(chunk);
Data *compressed = data_compress(serialized, compression_level);
data_destroy(serialized);
log_message(LOG_LEVEL_DEBUG, "Chunk successfully compressed");
return compressed;
}
@@ -143,99 +231,15 @@ Chunk *chunk_decompress(Data *compressed_data) {
log_message(LOG_LEVEL_ERROR, "Failed to decompress chunk data");
return NULL;
}
ArrayList *files = array_list_create(file_destroy);
char *data_pointer = uncompressed_data->data;
size_t remaining_size = uncompressed_data->size;
while (remaining_size > 0) {
if (remaining_size < sizeof(size_t)) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path length");
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
size_t path_len = *(size_t *)data_pointer;
data_pointer += sizeof(size_t);
remaining_size -= sizeof(size_t);
if (remaining_size < path_len) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path");
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
char *path = malloc(path_len + 1);
if (path == NULL) {
perror("Could not allocate memory for file path");
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
memcpy(path, data_pointer, path_len);
path[path_len] = '\0';
data_pointer += path_len;
remaining_size -= path_len;
if (remaining_size < sizeof(size_t)) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for data size");
free(path);
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
size_t data_size = *(size_t *)data_pointer;
data_pointer += sizeof(size_t);
remaining_size -= sizeof(size_t);
if (remaining_size < data_size) {
log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for file content");
free(path);
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
struct stat st = {0};
st.st_size = data_size;
File *file = file_create(path, &st);
if (file == NULL) {
free(path);
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
void *file_data = malloc(data_size);
if (file_data == NULL) {
perror("Could not allocate memory for file data");
free(path);
array_list_delete(files);
data_destroy(uncompressed_data);
return NULL;
}
memcpy(file_data, data_pointer, data_size);
file->data = data_create(file_data, data_size);
data_pointer += data_size;
remaining_size -= data_size;
array_list_add(files, file);
free(path);
Chunk *chunk = chunk_deserialize(uncompressed_data);
if (chunk == NULL) {
log_message(LOG_LEVEL_ERROR, "Failed to deserialize chunk data");
data_destroy(uncompressed_data);
return NULL;
}
// Create the chunk from the files
File **file_array = (File **)array_list_to_array(files);
Chunk *chunk = chunk_create(file_array, files->size);
// Clean up - files are now owned by the chunk
free(file_array);
files->item_destroyer = NULL;
array_list_delete(files);
data_destroy(uncompressed_data);
log_message(LOG_LEVEL_DEBUG, "Chunk successfully decompressed");
return chunk;
}