refactor: merge File/FileReceive, add optional metadata transfer with -M flag

- Remove FileReceive struct; use File everywhere with nullable FileMetadata*
- Remove struct stat from File; file size lives in Data->size (data_create_reserve)
- Add FileMetadata struct (mode, uid, gid, mtime) sent conditionally over wire
- Add -M / --preserve flag to client
- Restore permissions, ownership, timestamps on disk write
- Wire format uses per-file present flag for metadata (zero overhead when off)

src/shared/chunk.c

@@ -11,6 +11,8 @@
 #include "file.h"
 #include "log.h"
 
+#define FILE_METADATA_WIRE_SIZE (sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))
+
 Chunk *chunk_create(File **items, int element_count) {
   Chunk *chunk = (Chunk *)malloc(sizeof(Chunk));
   if (chunk == NULL) {
@@ -56,13 +58,44 @@ void chunk_print(void *item) {
       file_print(chunk->items[i]);
 }
 
+static void metadata_to_buf(char **buf, 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);
+}
+
+static 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);
+  return m;
+}
+
+static unsigned long long per_file_chunk_format_size(File *file) {
+  return sizeof(int) + strlen(file->path) + sizeof(int) +
+         (file->metadata ? FILE_METADATA_WIRE_SIZE : 0) +
+         sizeof(unsigned long long) + file->data->size;
+}
+
 Data *chunk_format(Chunk *chunk) {
   unsigned long long buffer_size = 0;
   for (int i = 0; i < chunk->element_count; ++i) {
-    buffer_size += sizeof(int);
-    buffer_size += strlen(chunk->items[i]->path);
-    buffer_size += sizeof(unsigned long long);
-    buffer_size += chunk->items[i]->stats.st_size;
+    buffer_size += per_file_chunk_format_size(chunk->items[i]);
   }
 
   char *data = malloc(buffer_size);
@@ -80,12 +113,14 @@ Data *chunk_format(Chunk *chunk) {
     // add path
     memcpy(current_data_pointer, file->path, path_length);
     current_data_pointer += path_length;
+    // add metadata
+    metadata_to_buf(&current_data_pointer, file->metadata);
     // add file data len
-    unsigned long long file_length = file->stats.st_size;
+    unsigned long long file_length = file->data->size;
     memcpy(current_data_pointer, &file_length, sizeof(unsigned long long));
     current_data_pointer += sizeof(unsigned long long);
     // add file data
-    if (file->data == NULL) {
+    if (file->data->data == NULL) {
       file_load_data(file);
     }
     memcpy(current_data_pointer, file->data->data, file_length);
@@ -98,13 +133,16 @@ Data *chunk_format(Chunk *chunk) {
   return chunk_data_create(data, buffer_size);
 }
 
+static unsigned long long per_file_serialize_size(File *file) {
+  return sizeof(size_t) + strlen(file->path) + sizeof(int) +
+         (file->metadata ? FILE_METADATA_WIRE_SIZE : 0) +
+         sizeof(size_t) + file->data->size;
+}
+
 Data *chunk_serialize(Chunk *chunk) {
   unsigned long long data_size = 0;
   for (int i = 0; i < chunk->element_count; i++) {
-    data_size += sizeof(size_t);
-    data_size += strlen(chunk->items[i]->path);
-    data_size += sizeof(size_t);
-    data_size += chunk->items[i]->stats.st_size;
+    data_size += per_file_serialize_size(chunk->items[i]);
   }
   Data *data = data_create_empty(data_size);
   if (data == NULL) {
@@ -114,16 +152,19 @@ Data *chunk_serialize(Chunk *chunk) {
   }
   char *data_pointer = data->data;
   for (int i = 0; i < chunk->element_count; i++) {
-    size_t path_len = strlen(chunk->items[i]->path);
+    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);
-    memcpy(data_pointer, chunk->items[i]->path, path_len);
+    memcpy(data_pointer, file->path, path_len);
     data_pointer += path_len;
 
-    size_t file_data_size = chunk->items[i]->stats.st_size;
+    metadata_to_buf(&data_pointer, file->metadata);
+
+    size_t file_data_size = file->data->size;
     memcpy(data_pointer, &file_data_size, sizeof(size_t));
     data_pointer += sizeof(size_t);
-    memcpy(data_pointer, chunk->items[i]->data->data, file_data_size);
+    memcpy(data_pointer, file->data->data, file_data_size);
     data_pointer += file_data_size;
   }
   return data;
@@ -162,9 +203,16 @@ Chunk *chunk_deserialize(Data *data) {
     data_pointer += path_len;
     remaining_size -= path_len;
 
+    File *file = file_create(path);
+    free(path);
+
+    file->metadata = metadata_from_buf(&data_pointer);
+    remaining_size -= sizeof(int);
+    if (file->metadata)
+      remaining_size -= FILE_METADATA_WIRE_SIZE;
+
     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;
     }
@@ -175,16 +223,6 @@ Chunk *chunk_deserialize(Data *data) {
 
     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;
     }
@@ -192,17 +230,16 @@ Chunk *chunk_deserialize(Data *data) {
     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);
+    data_destroy(file->data);
     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);
   }
 
   File **file_array = (File **)array_list_to_array(files);
@@ -260,36 +297,3 @@ void chunk_data_delete(void *chunk) {
   free(chunk_data->data);
   free(chunk_data);
 }
-
-// void chunk_data_to_disk(ChunkData *chunk_formated, char *root_directory) {
-//   char *current_data_pointer = chunk_formated->data;
-//   while (current_data_pointer - (char *)chunk_formated->data <
-//          chunk_formated->data_size) {
-//     // get path length
-//     int path_length = 0;
-//     memcpy(&path_length, (int *)current_data_pointer, sizeof(int));
-//     current_data_pointer += sizeof(int);
-//     // get path
-//     int path_dir_size =
-//         (strlen(root_directory) + path_length + 1) * sizeof(char);
-//     char *path = (char *)malloc(path_dir_size);
-//     if (path == NULL) {
-//       perror("Could not allocate memory for path!");
-//       exit(EXIT_FAILURE);
-//     }
-//     snprintf(path, path_dir_size, "%s%.*s", root_directory, path_length,
-//              current_data_pointer);
-//     current_data_pointer += sizeof(char) * path_length;
-//     // get data length
-//     unsigned long long data_size = 0;
-//     memcpy(&data_size, (unsigned long long *)current_data_pointer,
-//            sizeof(unsigned long long));
-//     current_data_pointer += sizeof(unsigned long long);
-//     // create File Receive
-//     FileReceive *file =
-//         file_receive_create(path, data_size, current_data_pointer);
-//     file_receive_print(file);
-//     file_receive_to_disk(file);
-//     current_data_pointer += sizeof(char) * data_size;
-//   }
-// }

src/shared/config.c

@@ -7,8 +7,8 @@
 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, int compression_level,
-                      int num_connections) {
+                      bool use_compression, bool use_metadata,
+                      int compression_level, int num_connections) {
 
   Config *config = malloc(sizeof(Config));
   config->version = version;
@@ -18,6 +18,7 @@ Config *config_create(char *version, char *send_directory,
   config->use_multithreading = use_multithreading;
   config->use_chunk_serialization = use_chunk_serialization;
   config->use_compression = use_compression;
+  config->use_metadata = use_metadata;
   config->compression_level = compression_level;
   config->num_connections = num_connections;
   return config;
@@ -38,6 +39,7 @@ void config_send(int file_descriptor, Config *config) {
   send_int(file_descriptor, config->use_multithreading);
   send_int(file_descriptor, config->use_chunk_serialization);
   send_int(file_descriptor, config->use_compression);
+  send_int(file_descriptor, config->use_metadata);
   send_int(file_descriptor, config->compression_level);
   send_int(file_descriptor, config->num_connections);
   if (receive_status(file_descriptor) != STATUS_OK) {
@@ -55,6 +57,7 @@ Config *config_receive(int file_descriptor) {
   config->use_multithreading = receive_int(file_descriptor);
   config->use_chunk_serialization = receive_int(file_descriptor);
   config->use_compression = receive_int(file_descriptor);
+  config->use_metadata = receive_int(file_descriptor);
   config->compression_level = receive_int(file_descriptor);
   config->num_connections = receive_int(file_descriptor);
   send_status(file_descriptor, STATUS_OK);

src/shared/config.h

@@ -12,6 +12,7 @@ typedef struct Config {
   bool use_chunk_serialization;
   bool use_compression;
   bool use_single_send_per_file;
+  bool use_metadata;
   int compression_level;
   int num_connections;
 } Config;
@@ -19,8 +20,8 @@ typedef struct 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, int compression_level,
-                      int num_connections);
+                      bool use_compression, bool use_metadata,
+                      int compression_level, int num_connections);
 void config_delete(Config *config);
 void config_send(int file_descriptor, Config *config);
 Config *config_receive(int file_descriptor);

src/shared/data.c

@@ -13,6 +13,17 @@ 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));
+  if (d == NULL) {
+    log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
+    exit(EXIT_FAILURE);
+  }
+  d->data = NULL;
+  d->size = size;
+  return d;
+}
+
 Data *data_create(void *data, size_t data_size) {
   Data *new_data = malloc(sizeof(Data));
   if (new_data == NULL) {

src/shared/data.h

@@ -9,6 +9,7 @@ typedef struct {
 } 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_compress(Data *data_to_compress, int compression_level);

src/shared/file.c

@@ -11,15 +11,13 @@
 #include "log.h"
 #include "socket.h"
 
-File *file_create(const char *path, struct stat *stats) {
+File *file_create(const char *path) {
   File *file = (File *)malloc(sizeof(File));
   if (file == NULL) {
     perror("FATAL ERROR: Could not allocate memory for file struct");
     exit(EXIT_FAILURE);
   }
 
-  file->stats = *stats;
-
   int path_len = strlen(path);
   file->path = (char *)malloc(path_len + 1);
   if (file->path == NULL) {
@@ -29,7 +27,8 @@ File *file_create(const char *path, struct stat *stats) {
   }
 
   strcpy(file->path, path);
-  file->data = NULL;
+  file->data = data_create_reserve(0);
+  file->metadata = NULL;
   return file;
 }
 
@@ -39,15 +38,40 @@ void file_destroy(void *item) {
   File *file = (File *)item;
   data_destroy(file->data);
   file->data = NULL;
+  file_metadata_destroy(file->metadata);
+  file->metadata = NULL;
   free(file->path);
   file->path = NULL;
   free(file);
 }
 
+FileMetadata *file_metadata_create(struct stat *stats) {
+  FileMetadata *m = malloc(sizeof(FileMetadata));
+  if (m == NULL) {
+    perror("FATAL ERROR: Could not allocate memory for file metadata");
+    exit(EXIT_FAILURE);
+  }
+  m->mode = stats->st_mode;
+  m->uid = stats->st_uid;
+  m->gid = stats->st_gid;
+  m->mtime_sec = stats->st_mtime;
+#ifdef __linux__
+  m->mtime_nsec = stats->st_mtim.tv_nsec;
+#else
+  m->mtime_nsec = 0;
+#endif
+  return m;
+}
+
+void file_metadata_destroy(void *metadata) {
+  free(metadata);
+}
+
 void file_load_data(File *file) {
   if (file == NULL)
     return;
-  file->data = data_create_empty(file->stats.st_size);
+  if (file->data->data == NULL)
+    file->data->data = malloc(file->data->size);
   printf("%ld is file big", file->data->size);
   size_t bytes_read = file_content_to_buffer(file);
   if (bytes_read != file->data->size) {
@@ -62,8 +86,38 @@ void file_print(void *item) {
   printf("%s\n", ((File *)item)->path);
 }
 
+static void metadata_send(int file_descriptor, FileMetadata *m) {
+  if (m == NULL) {
+    int zero = 0;
+    send_n_data(file_descriptor, &zero, sizeof(int));
+    return;
+  }
+  int present = 1;
+  send_n_data(file_descriptor, &present, sizeof(int));
+  send_n_data(file_descriptor, &m->mode, sizeof(mode_t));
+  send_n_data(file_descriptor, &m->uid, sizeof(uid_t));
+  send_n_data(file_descriptor, &m->gid, sizeof(gid_t));
+  send_n_data(file_descriptor, &m->mtime_sec, sizeof(time_t));
+  send_n_data(file_descriptor, &m->mtime_nsec, sizeof(long));
+}
+
+FileMetadata *file_receive_metadata(int file_descriptor) {
+  int present;
+  receive_n_data(file_descriptor, &present, sizeof(int));
+  if (!present)
+    return NULL;
+  FileMetadata *m = malloc(sizeof(FileMetadata));
+  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));
+  return m;
+}
+
 void file_send_single_calls(File *file, int file_descriptor) {
   send_str(file_descriptor, file->path);
+  metadata_send(file_descriptor, file->metadata);
   printf("Sending File: %ld", file->data->size);
   send_data(file_descriptor, file->data->data, file->data->size);
 }
@@ -75,29 +129,11 @@ size_t file_content_to_buffer(File *file) {
     return 0;
   }
   size_t bytes_read =
-      fread(file->data->data, 1, file->stats.st_size, file_pointer);
-  if (bytes_read != (size_t)file->stats.st_size) {
+      fread(file->data->data, 1, file->data->size, file_pointer);
+  if (bytes_read != (size_t)file->data->size) {
     perror("Read to many or to less bytes from File!");
     return 0;
   }
   fclose(file_pointer);
   return bytes_read;
 }
-
-FileReceive *file_receive_create(char *path, Data *data) {
-  FileReceive *file = malloc(sizeof(FileReceive));
-  file->path = path;
-  file->data = data;
-  return file;
-}
-
-void file_receive_destroy(void *file_receive) {
-  if (file_receive == NULL)
-    return;
-  FileReceive *file = (FileReceive *)file_receive;
-  data_destroy(file->data);
-  free(file->path);
-  free(file);
-}
-
-

src/shared/file.h

@@ -5,24 +5,27 @@
 #include <sys/stat.h>
 
 typedef struct {
-  char *path;
-  struct stat stats;
-  Data *data;
-} File;
+  mode_t mode;
+  uid_t uid;
+  gid_t gid;
+  time_t mtime_sec;
+  long mtime_nsec;
+} FileMetadata;
 
 typedef struct {
   char *path;
   Data *data;
-} FileReceive;
+  FileMetadata *metadata;
+} File;
 
-File *file_create(const char *path, struct stat *stats);
+File *file_create(const char *path);
 void file_destroy(void *item);
 void file_load_data(File *file);
 void file_print(void *item);
 void file_send_single_calls(File *file, int file_descriptor);
 size_t file_content_to_buffer(File *file);
-
-FileReceive *file_receive_create(char *path, Data *data);
-void file_receive_destroy(void *file_receive);
+FileMetadata *file_metadata_create(struct stat *stats);
+void file_metadata_destroy(void *metadata);
+FileMetadata *file_receive_metadata(int file_descriptor);
 
 #endif

src/shared/utils.c

@@ -1,9 +1,12 @@
 #include "utils.h"
 #include "libgen.h"
 #include "sys/stat.h"
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
+#include <unistd.h>
 
 void mkdir_r(char *path) {
   char *path_duplicate = malloc(strlen(path) + 1);
@@ -59,6 +62,19 @@ void to_disk(char *path, void *data, unsigned long long data_size) {
   free(dir_to_free);
 }
 
+void file_restore_metadata(const char *path, FileMetadata *metadata) {
+  if (metadata == NULL)
+    return;
+  chmod(path, metadata->mode & 07777);
+  chown(path, metadata->uid, metadata->gid);
+  struct timespec times[2];
+  times[0].tv_sec = 0;
+  times[0].tv_nsec = UTIME_OMIT;
+  times[1].tv_sec = metadata->mtime_sec;
+  times[1].tv_nsec = metadata->mtime_nsec;
+  utimensat(AT_FDCWD, path, times, 0);
+}
+
 char *path_cat(char *path1, char *path2) {
   if (path1 == NULL || *path1 == '\0')
     return str_dup(path2);

src/shared/utils.h

@@ -1,9 +1,12 @@
 #ifndef UTILS_H
 #define UTILS_H
 
+#include "file.h"
+
 void mkdir_r(char *path);
 char *str_dup(char *string);
 void to_disk(char *path, void *data, unsigned long long data_size);
+void file_restore_metadata(const char *path, FileMetadata *metadata);
 char *path_cat(char *path1, char *path2);
 
 #endif