From 1442d234fb6681e32b10348a6c7b226c11629203 Mon Sep 17 00:00:00 2001 From: sairoop-elear Date: Sun, 21 Apr 2019 09:15:42 +0530 Subject: [PATCH] Modify meshlink configuration base file structre --- src/conf.c | 475 +++++++++++++++++++++++++++++++++++--------- src/conf.h | 32 +-- src/devtools.c | 11 +- src/meshlink.c | 47 +++-- src/meshlink.h | 2 +- src/net_setup.c | 22 +- src/protocol_auth.c | 5 +- 7 files changed, 465 insertions(+), 129 deletions(-) diff --git a/src/conf.c b/src/conf.c index 1a3c82ae..5db2c016 100644 --- a/src/conf.c +++ b/src/conf.c @@ -19,6 +19,8 @@ #include "system.h" #include +#include +#include #include "conf.h" #include "crypto.h" @@ -28,23 +30,23 @@ #include "packmsg.h" /// Generate a path to the main configuration file. -static void make_main_path(meshlink_handle_t *mesh, char *path, size_t len) { - snprintf(path, len, "%s" SLASH "meshlink.conf", mesh->confbase); +static void make_main_path(meshlink_handle_t *mesh, const char *conf_subdir, char *path, size_t len) { + snprintf(path, len, "%s" SLASH "%s" SLASH "meshlink.conf", mesh->confbase, conf_subdir); } /// Generate a path to a host configuration file. -static void make_host_path(meshlink_handle_t *mesh, const char *name, char *path, size_t len) { - snprintf(path, len, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name); +static void make_host_path(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, char *path, size_t len) { + snprintf(path, len, "%s" SLASH "%s" SLASH "hosts" SLASH "%s", mesh->confbase, conf_subdir, name); } /// Generate a path to an unused invitation file. -static void make_invitation_path(meshlink_handle_t *mesh, const char *name, char *path, size_t len) { - snprintf(path, len, "%s" SLASH "invitations" SLASH "%s", mesh->confbase, name); +static void make_invitation_path(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, char *path, size_t len) { + snprintf(path, len, "%s" SLASH "%s" SLASH "invitations" SLASH "%s", mesh->confbase, conf_subdir, name); } /// Generate a path to a used invitation file. -static void make_used_invitation_path(meshlink_handle_t *mesh, const char *name, char *path, size_t len) { - snprintf(path, len, "%s" SLASH "invitations" SLASH "%s.used", mesh->confbase, name); +static void make_used_invitation_path(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, char *path, size_t len) { + snprintf(path, len, "%s" SLASH "%s" SLASH "invitations" SLASH "%s.used", mesh->confbase, conf_subdir, name); } /// Remove a directory recursively @@ -73,12 +75,60 @@ static void deltree(const char *dirname) { rmdir(dirname); } +static bool sync_path(const char *pathname) { + int fd = open(pathname, O_RDONLY); + + if(fd < 0) { + logger(NULL, MESHLINK_ERROR, "Failed to open %s: %s\n", pathname, strerror(errno)); + return false; + } + + if(fsync(fd)) { + logger(NULL, MESHLINK_ERROR, "Failed to sync %s: %s\n", pathname, strerror(errno)); + close(fd); + return false; + } + + if(close(fd)) { + logger(NULL, MESHLINK_ERROR, "Failed to close %s: %s\n", pathname, strerror(errno)); + close(fd); + return false; + } + + return true; +} + +/// Try decrypting the main configuration file from the given sub-directory. +static bool main_config_decrypt(meshlink_handle_t *mesh, const char *conf_subdir) { + if(!mesh->config_key && !mesh->confbase && !conf_subdir) { + return false; + } + + config_t config; + + if(!main_config_read(mesh, conf_subdir, &config, mesh->config_key)) { + logger(mesh, MESHLINK_ERROR, "Could not read main configuration file"); + return false; + } + + packmsg_input_t in = {config.buf, config.len}; + + uint32_t version = packmsg_get_uint32(&in); + config_free(&config); + + return version == MESHLINK_CONFIG_VERSION; +} + /// Create a fresh configuration directory -bool config_init(meshlink_handle_t *mesh) { +bool config_init(meshlink_handle_t *mesh, const char *conf_subdir) { if(!mesh->confbase) { return true; } + if(!conf_subdir) { + return false; + } + if(mkdir(mesh->confbase, 0700) && errno != EEXIST) { logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", mesh->confbase, strerror(errno)); return false; @@ -86,24 +136,25 @@ bool config_init(meshlink_handle_t *mesh) { char path[PATH_MAX]; - // Remove meshlink.conf - snprintf(path, sizeof(path), "%s" SLASH "meshlink.conf", mesh->confbase); - unlink(path); - - // Remove any host config files - snprintf(path, sizeof(path), "%s" SLASH "hosts", mesh->confbase); + // Create "current" sub-directory in the confbase + snprintf(path, sizeof(path), "%s" SLASH "%s", mesh->confbase, conf_subdir); deltree(path); - if(mkdir(path, 0700) && errno != EEXIST) { + if(mkdir(path, 0700)) { logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno)); return false; } - // Remove any invitation files - snprintf(path, sizeof(path), "%s" SLASH "invitations", mesh->confbase); - deltree(path); + make_host_path(mesh, conf_subdir, "", path, sizeof(path)); + + if(mkdir(path, 0700)) { + logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno)); + return false; + } - if(mkdir(path, 0700) && errno != EEXIST) { + make_invitation_path(mesh, conf_subdir, "", path, sizeof(path)); + + if(mkdir(path, 0700)) { logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno)); return false; } @@ -112,39 +163,255 @@ bool config_init(meshlink_handle_t *mesh) { } /// Wipe an existing configuration directory -bool config_destroy(const char *confbase) { +bool config_destroy(const char *confbase, const char *conf_subdir) { + if(!confbase && !conf_subdir) { + return false; + } + + struct stat st; + char path[PATH_MAX]; - // Remove meshlink.conf - snprintf(path, sizeof(path), "%s" SLASH "meshlink.conf", confbase); + // Check the presence of configuration base sub directory. + snprintf(path, sizeof(path), "%s" SLASH "%s", confbase, conf_subdir); - if(unlink(path)) { + if(stat(path, &st)) { if(errno == ENOENT) { - meshlink_errno = MESHLINK_ENOENT; - return false; + return true; } else { + logger(NULL, MESHLINK_ERROR, "Cannot stat %s: %s\n", path, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + } + + // Remove meshlink.conf + snprintf(path, sizeof(path), "%s" SLASH "%s" SLASH "meshlink.conf", confbase, conf_subdir); + + if(unlink(path)) { + if(errno != ENOENT) { logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", path, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; return false; } } - deltree(confbase); + snprintf(path, sizeof(path), "%s" SLASH "%s", confbase, conf_subdir); + deltree(path); return true; } +static bool copytree(const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key) { + if(!src_dir_name || !dst_dir_name) { + return false; + } + + DIR *src_dir = opendir(src_dir_name); + + if(!src_dir) { + logger(NULL, MESHLINK_ERROR, "Could not open directory file %s\n", src_dir_name); + return false; + } + + struct dirent *ent; + + while((ent = readdir(src_dir))) { + if(ent->d_name[0] == '.') { + continue; + } + + char src_filename[PATH_MAX]; + char dst_filename[PATH_MAX]; + + snprintf(dst_filename, sizeof(dst_filename), "%s" SLASH "%s", dst_dir_name, ent->d_name); + snprintf(src_filename, sizeof(src_filename), "%s" SLASH "%s", src_dir_name, ent->d_name); + + if(ent->d_type == DT_DIR) { + + // Delete if already exists and create a new destination directory + deltree(dst_filename); + + if(mkdir(dst_filename, 0700)) { + logger(NULL, MESHLINK_ERROR, "Could create directory %s\n", dst_filename); + return false; + } + + if(!copytree(src_filename, src_key, dst_filename, dst_key)) { + logger(NULL, MESHLINK_ERROR, "Copying %s to %s failed\n", src_filename, dst_filename); + return false; + } + + if(!sync_path(dst_filename)) { + return false; + } + + } else if(ent->d_type == DT_REG) { + struct stat st; + config_t config; + + if(stat(src_filename, &st)) { + logger(NULL, MESHLINK_ERROR, "Could not stat file `%s': %s\n", src_filename, strerror(errno)); + return false; + } + + FILE *f = fopen(src_filename, "r"); + + if(!f) { + logger(NULL, MESHLINK_ERROR, "Failed to open `%s': %s\n", src_filename, strerror(errno)); + return false; + } + + if(!config_read_file(NULL, f, &config, src_key)) { + logger(NULL, MESHLINK_ERROR, "Failed to read `%s': %s\n", src_filename, strerror(errno)); + fclose(f); + return false; + } + + if(fclose(f)) { + logger(NULL, MESHLINK_ERROR, "Failed to close `%s': %s\n", src_filename, strerror(errno)); + config_free(&config); + return false; + } + + f = fopen(dst_filename, "w"); + + if(!f) { + logger(NULL, MESHLINK_ERROR, "Failed to open `%s': %s", dst_filename, strerror(errno)); + config_free(&config); + return false; + } + + if(!config_write_file(NULL, f, &config, dst_key)) { + logger(NULL, MESHLINK_ERROR, "Failed to write `%s': %s", dst_filename, strerror(errno)); + config_free(&config); + fclose(f); + return false; + } + + if(fclose(f)) { + logger(NULL, MESHLINK_ERROR, "Failed to close `%s': %s", dst_filename, strerror(errno)); + config_free(&config); + return false; + } + + config_free(&config); + + struct utimbuf times; + times.modtime = st.st_mtime; + times.actime = st.st_atime; + + if(utime(dst_filename, ×)) { + logger(NULL, MESHLINK_ERROR, "Failed to utime `%s': %s", dst_filename, strerror(errno)); + return false; + } + } + } + + closedir(src_dir); + return true; +} + +bool config_copy(meshlink_handle_t *mesh, const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key) { + char src_filename[PATH_MAX]; + char dst_filename[PATH_MAX]; + + snprintf(dst_filename, sizeof(dst_filename), "%s" SLASH "%s", mesh->confbase, dst_dir_name); + snprintf(src_filename, sizeof(src_filename), "%s" SLASH "%s", mesh->confbase, src_dir_name); + + if(main_config_exists(mesh, dst_dir_name)) { + deltree(dst_dir_name); + } + + if(mkdir(dst_filename, 0700)) { + logger(NULL, MESHLINK_ERROR, "Could create directory %s\n", dst_filename); + return false; + } + + return copytree(src_filename, src_key, dst_filename, dst_key); +} + /// Check the presence of the main configuration file. -bool main_config_exists(meshlink_handle_t *mesh) { - if(!mesh->confbase) { +bool main_config_exists(meshlink_handle_t *mesh, const char *conf_subdir) { + if(!mesh->confbase && !conf_subdir) { return false; } char path[PATH_MAX]; - make_main_path(mesh, path, sizeof(path)); - + make_main_path(mesh, conf_subdir, path, sizeof(path)); return access(path, F_OK) == 0; } +bool config_rename(meshlink_handle_t *mesh, const char *old_conf_subdir, const char *new_conf_subdir) { + if(!mesh->confbase && !old_conf_subdir && !new_conf_subdir) { + return false; + } + + char old_path[PATH_MAX]; + char new_path[PATH_MAX]; + + snprintf(old_path, sizeof(old_path), "%s" SLASH "%s", mesh->confbase, old_conf_subdir); + snprintf(new_path, sizeof(new_path), "%s" SLASH "%s", mesh->confbase, new_conf_subdir); + + return rename(old_path, new_path) == 0; +} + +bool meshlink_confbase_exists(meshlink_handle_t *mesh) { + if(!mesh->confbase) { + return false; + } + + bool confbase_exists = false; + bool confbase_decryptable = false; + + if(main_config_exists(mesh, "current")) { + confbase_exists = true; + + if(mesh->config_key && main_config_decrypt(mesh, "current")) { + confbase_decryptable = true; + } + } + + if(mesh->config_key && !confbase_decryptable && main_config_exists(mesh, "new")) { + confbase_exists = true; + + if(main_config_decrypt(mesh, "new")) { + if(!config_destroy(mesh->confbase, "current")) { + return false; + } + + if(!config_rename(mesh, "new", "current")) { + return false; + } + + confbase_decryptable = true; + } + } + + if(mesh->config_key && !confbase_decryptable && main_config_exists(mesh, "old")) { + confbase_exists = true; + + if(main_config_decrypt(mesh, "old")) { + if(!config_destroy(mesh->confbase, "current")) { + return false; + } + + if(!config_rename(mesh, "old", "current")) { + return false; + } + + confbase_decryptable = true; + } + } + + // Cleanup if current is existing with old and new + if(confbase_exists && confbase_decryptable) { + config_destroy(mesh->confbase, "old"); + config_destroy(mesh->confbase, "new"); + } + + return confbase_exists; +} + /// Lock the main configuration file. bool main_config_lock(meshlink_handle_t *mesh) { if(!mesh->confbase) { @@ -152,7 +419,7 @@ bool main_config_lock(meshlink_handle_t *mesh) { } char path[PATH_MAX]; - make_main_path(mesh, path, sizeof(path)); + make_main_path(mesh, "current", path, sizeof(path)); mesh->conffile = fopen(path, "r"); @@ -192,12 +459,7 @@ void main_config_unlock(meshlink_handle_t *mesh) { } /// Read a configuration file from a FILE handle. -bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config) { - if(!mesh->confbase) { - return false; - } - - (void)mesh; +bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config, const void *key) { long len; if(fseek(f, 0, SEEK_END) || !(len = ftell(f)) || fseek(f, 0, SEEK_SET)) { @@ -216,11 +478,11 @@ bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config) { return false; } - if(mesh->config_key) { + if(key) { uint8_t *decrypted = xmalloc(len); size_t decrypted_len = len; chacha_poly1305_ctx_t *ctx = chacha_poly1305_init(); - chacha_poly1305_set_key(ctx, mesh->config_key); + chacha_poly1305_set_key(ctx, key); if(len > 12 && chacha_poly1305_decrypt_iv96(ctx, buf, buf + 12, len - 12, decrypted, &decrypted_len)) { chacha_poly1305_exit(ctx); @@ -245,18 +507,14 @@ bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config) { } /// Write a configuration file to a FILE handle. -bool config_write_file(meshlink_handle_t *mesh, FILE *f, const config_t *config) { - if(!mesh->confbase) { - return true; - } - - if(mesh->config_key) { +bool config_write_file(meshlink_handle_t *mesh, FILE *f, const config_t *config, const void *key) { + if(key) { uint8_t buf[config->len + 16]; size_t len = sizeof(buf); uint8_t seqbuf[12]; randomize(&seqbuf, sizeof(seqbuf)); chacha_poly1305_ctx_t *ctx = chacha_poly1305_init(); - chacha_poly1305_set_key(ctx, mesh->config_key); + chacha_poly1305_set_key(ctx, key); bool success = false; if(chacha_poly1305_encrypt_iv96(ctx, seqbuf, config->buf, config->len, buf, &len)) { @@ -276,6 +534,11 @@ bool config_write_file(meshlink_handle_t *mesh, FILE *f, const config_t *config) return false; } + if(fsync(fileno(f))) { + logger(mesh, MESHLINK_ERROR, "Failed to sync file: %s\n", strerror(errno)); + return false; + } + return true; } @@ -287,25 +550,25 @@ void config_free(config_t *config) { } /// Check the presence of a host configuration file. -bool config_exists(meshlink_handle_t *mesh, const char *name) { - if(!mesh->confbase) { +bool config_exists(meshlink_handle_t *mesh, const char *conf_subdir, const char *name) { + if(!mesh->confbase && !conf_subdir) { return false; } char path[PATH_MAX]; - make_host_path(mesh, name, path, sizeof(path)); + make_host_path(mesh, conf_subdir, name, path, sizeof(path)); return access(path, F_OK) == 0; } /// Read a host configuration file. -bool config_read(meshlink_handle_t *mesh, const char *name, config_t *config) { - if(!mesh->confbase) { +bool config_read(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, config_t *config, void *key) { + if(!mesh->confbase && !conf_subdir) { return false; } char path[PATH_MAX]; - make_host_path(mesh, name, path, sizeof(path)); + make_host_path(mesh, conf_subdir, name, path, sizeof(path)); FILE *f = fopen(path, "r"); @@ -314,49 +577,61 @@ bool config_read(meshlink_handle_t *mesh, const char *name, config_t *config) { return false; } - if(!config_read_file(mesh, f, config)) { + if(!config_read_file(mesh, f, config, key)) { logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); fclose(f); return false; } - fclose(f); + if(fclose(f)) { + logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno)); + return false; + } + return true; } -void config_scan_all(meshlink_handle_t *mesh, config_scan_action_t action) { - if(!mesh->confbase) { - return; +bool config_scan_all(meshlink_handle_t *mesh, const char *conf_subdir, const char *conf_type, config_scan_action_t action, void *arg) { + if(!mesh->confbase && !conf_subdir && !conf_type) { + return false; } DIR *dir; struct dirent *ent; char dname[PATH_MAX]; - make_host_path(mesh, "", dname, sizeof(dname)); + snprintf(dname, sizeof(dname), "%s" SLASH "%s" SLASH "%s", mesh->confbase, conf_subdir, conf_type); dir = opendir(dname); if(!dir) { logger(mesh, MESHLINK_ERROR, "Could not open %s: %s", dname, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; - return; + return false; } while((ent = readdir(dir))) { - action(mesh, ent->d_name); + if(ent->d_name[0] == '.') { + continue; + } + + if(!action(mesh, ent->d_name, arg)) { + closedir(dir); + return false; + } } closedir(dir); + return true; } /// Write a host configuration file. -bool config_write(meshlink_handle_t *mesh, const char *name, const config_t *config) { - if(!mesh->confbase) { +bool config_write(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, const config_t *config, void *key) { + if(!mesh->confbase && !conf_subdir && !name) { return true; } char path[PATH_MAX]; - make_host_path(mesh, name, path, sizeof(path)); + make_host_path(mesh, conf_subdir, name, path, sizeof(path)); FILE *f = fopen(path, "w"); @@ -365,24 +640,28 @@ bool config_write(meshlink_handle_t *mesh, const char *name, const config_t *con return false; } - if(!config_write_file(mesh, f, config)) { + if(!config_write_file(mesh, f, config, key)) { logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); fclose(f); return false; } - fclose(f); + if(fclose(f)) { + logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno)); + return false; + } + return true; } /// Read the main configuration file. -bool main_config_read(meshlink_handle_t *mesh, config_t *config) { - if(!mesh->confbase) { +bool main_config_read(meshlink_handle_t *mesh, const char *conf_subdir, config_t *config, void *key) { + if(!mesh->confbase && !conf_subdir) { return false; } char path[PATH_MAX]; - make_main_path(mesh, path, sizeof(path)); + make_main_path(mesh, conf_subdir, path, sizeof(path)); FILE *f = fopen(path, "r"); @@ -391,24 +670,28 @@ bool main_config_read(meshlink_handle_t *mesh, config_t *config) { return false; } - if(!config_read_file(mesh, f, config)) { + if(!config_read_file(mesh, f, config, key)) { logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); fclose(f); return false; } - fclose(f); + if(fclose(f)) { + logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno)); + return false; + } + return true; } /// Write the main configuration file. -bool main_config_write(meshlink_handle_t *mesh, const config_t *config) { - if(!mesh->confbase) { +bool main_config_write(meshlink_handle_t *mesh, const char *conf_subdir, const config_t *config, void *key) { + if(!mesh->confbase && !conf_subdir) { return true; } char path[PATH_MAX]; - make_main_path(mesh, path, sizeof(path)); + make_main_path(mesh, conf_subdir, path, sizeof(path)); FILE *f = fopen(path, "w"); @@ -417,26 +700,30 @@ bool main_config_write(meshlink_handle_t *mesh, const config_t *config) { return false; } - if(!config_write_file(mesh, f, config)) { + if(!config_write_file(mesh, f, config, key)) { logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); fclose(f); return false; } - fclose(f); + if(fclose(f)) { + logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno)); + return false; + } + return true; } -/// Read an invitation file, and immediately delete it. -bool invitation_read(meshlink_handle_t *mesh, const char *name, config_t *config) { - if(!mesh->confbase) { +/// Read an invitation file from the confbase sub-directory, and immediately delete it. +bool invitation_read(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, config_t *config, void *key) { + if(!mesh->confbase && !conf_subdir) { return false; } char path[PATH_MAX]; char used_path[PATH_MAX]; - make_invitation_path(mesh, name, path, sizeof(path)); - make_used_invitation_path(mesh, name, used_path, sizeof(used_path)); + make_invitation_path(mesh, conf_subdir, name, path, sizeof(path)); + make_used_invitation_path(mesh, conf_subdir, name, used_path, sizeof(used_path)); // Atomically rename the invitation file if(rename(path, used_path)) { @@ -473,26 +760,30 @@ bool invitation_read(meshlink_handle_t *mesh, const char *name, config_t *config return false; } - if(!config_read_file(mesh, f, config)) { + if(!config_read_file(mesh, f, config, key)) { logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); fclose(f); unlink(used_path); return false; } - fclose(f); + if(fclose(f)) { + logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno)); + return false; + } + unlink(used_path); return true; } /// Write an invitation file. -bool invitation_write(meshlink_handle_t *mesh, const char *name, const config_t *config) { - if(!mesh->confbase) { - return true; +bool invitation_write(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, const config_t *config, void *key) { + if(!mesh->confbase && !conf_subdir) { + return false; } char path[PATH_MAX]; - make_invitation_path(mesh, name, path, sizeof(path)); + make_invitation_path(mesh, conf_subdir, name, path, sizeof(path)); FILE *f = fopen(path, "w"); @@ -501,13 +792,17 @@ bool invitation_write(meshlink_handle_t *mesh, const char *name, const config_t return false; } - if(!config_write_file(mesh, f, config)) { + if(!config_write_file(mesh, f, config, key)) { logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); fclose(f); return false; } - fclose(f); + if(fclose(f)) { + logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno)); + return false; + } + return true; } @@ -518,7 +813,7 @@ size_t invitation_purge_old(meshlink_handle_t *mesh, time_t deadline) { } char path[PATH_MAX]; - make_invitation_path(mesh, "", path, sizeof(path)); + make_invitation_path(mesh, "current", "", path, sizeof(path)); DIR *dir = opendir(path); diff --git a/src/conf.h b/src/conf.h index 63d5fef4..93ee5bb9 100644 --- a/src/conf.h +++ b/src/conf.h @@ -27,28 +27,32 @@ typedef struct config_t { size_t len; } config_t; -typedef void (*config_scan_action_t)(struct meshlink_handle *mesh, const char *name); +typedef bool (*config_scan_action_t)(struct meshlink_handle *mesh, const char *name, void *arg); -//extern bool config_read_file(struct meshlink_handle *mesh, FILE *f, struct config_t *); -//extern bool config_write_file(struct meshlink_handle *mesh, FILE *f, const struct config_t *); +extern bool config_read_file(struct meshlink_handle *mesh, FILE *f, struct config_t *, const void *key); +extern bool config_write_file(struct meshlink_handle *mesh, FILE *f, const struct config_t *, const void *key); extern void config_free(struct config_t *config); -extern bool config_init(struct meshlink_handle *mesh); -extern bool config_destroy(const char *confbase); +extern bool meshlink_confbase_exists(struct meshlink_handle *mesh); -extern bool main_config_exists(struct meshlink_handle *mesh); +extern bool config_init(struct meshlink_handle *mesh, const char *conf_subdir); +extern bool config_destroy(const char *confbase, const char *conf_subdir); +extern bool config_copy(struct meshlink_handle *mesh, const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key); +extern bool config_rename(struct meshlink_handle *mesh, const char *old_conf_subdir, const char *new_conf_subdir); + +extern bool main_config_exists(struct meshlink_handle *mesh, const char *conf_subdir); extern bool main_config_lock(struct meshlink_handle *mesh); extern void main_config_unlock(struct meshlink_handle *mesh); -extern bool main_config_read(struct meshlink_handle *mesh, struct config_t *); -extern bool main_config_write(struct meshlink_handle *mesh, const struct config_t *); +extern bool main_config_read(struct meshlink_handle *mesh, const char *conf_subdir, struct config_t *, void *key); +extern bool main_config_write(struct meshlink_handle *mesh, const char *conf_subdir, const struct config_t *, void *key); -extern bool config_exists(struct meshlink_handle *mesh, const char *name); -extern bool config_read(struct meshlink_handle *mesh, const char *name, struct config_t *); -extern bool config_write(struct meshlink_handle *mesh, const char *name, const struct config_t *); -extern void config_scan_all(struct meshlink_handle *mesh, config_scan_action_t action); +extern bool config_exists(struct meshlink_handle *mesh, const char *conf_subdir, const char *name); +extern bool config_read(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, struct config_t *, void *key); +extern bool config_write(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, const struct config_t *, void *key); +extern bool config_scan_all(struct meshlink_handle *mesh, const char *conf_subdir, const char *conf_type, config_scan_action_t action, void *arg); -extern bool invitation_read(struct meshlink_handle *mesh, const char *name, struct config_t *); -extern bool invitation_write(struct meshlink_handle *mesh, const char *name, const struct config_t *); +extern bool invitation_read(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, struct config_t *, void *key); +extern bool invitation_write(struct meshlink_handle *mesh, const char *conf_subdir, const char *name, const struct config_t *, void *key); extern size_t invitation_purge_old(struct meshlink_handle *mesh, time_t deadline); #endif diff --git a/src/devtools.c b/src/devtools.c index 2aba935b..5991d70c 100644 --- a/src/devtools.c +++ b/src/devtools.c @@ -30,12 +30,17 @@ #include "devtools.h" -static void nop_probe(void) { +static void trybind_nop_probe(void) { return; } -void (*devtool_trybind_probe)(void) = nop_probe; -void (*devtool_keyrotate_probe)(int stage) = nop_probe; +static void keyrotate_nop_probe(int stage) { + (void)stage; + return; +} + +void (*devtool_trybind_probe)(void) = trybind_nop_probe; +void (*devtool_keyrotate_probe)(int stage) = keyrotate_nop_probe; /* Return an array of edges in the current network graph. * Data captures the current state and will not be updated. diff --git a/src/meshlink.c b/src/meshlink.c index 89baa328..185f6689 100644 --- a/src/meshlink.c +++ b/src/meshlink.c @@ -531,6 +531,10 @@ int check_port(meshlink_handle_t *mesh) { } static bool write_main_config_files(meshlink_handle_t *mesh) { + if(!mesh->confbase) { + return true; + } + uint8_t buf[4096]; /* Write the main config file */ @@ -548,7 +552,7 @@ static bool write_main_config_files(meshlink_handle_t *mesh) { config_t config = {buf, packmsg_output_size(&out, buf)}; - if(!main_config_write(mesh, &config)) { + if(!main_config_write(mesh, "current", &config, mesh->config_key)) { return false; } @@ -598,7 +602,7 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len mesh->self->devclass = devclass; // Initialize configuration directory - if(!config_init(mesh)) { + if(!config_init(mesh, "current")) { return false; } @@ -652,7 +656,7 @@ static bool finalize_join(meshlink_handle_t *mesh, const void *buf, uint16_t len node_add(mesh, n); - if(!config_write(mesh, n->name, &config)) { + if(!config_write(mesh, "current", n->name, &config, mesh->config_key)) { return false; } } @@ -856,8 +860,8 @@ static void add_local_addresses(meshlink_handle_t *mesh) { } static bool meshlink_setup(meshlink_handle_t *mesh) { - if(!config_init(mesh)) { - logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s: %s\n", mesh->confbase, strerror(errno)); + if(!config_init(mesh, "current")) { + logger(mesh, MESHLINK_ERROR, "Could not set up configuration in %s/current: %s\n", mesh->confbase, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; return false; } @@ -880,6 +884,8 @@ static bool meshlink_setup(meshlink_handle_t *mesh) { mesh->self->ecdsa = ecdsa_set_public_key(ecdsa_get_public_key(mesh->private_key)); if(!write_main_config_files(mesh)) { + logger(mesh, MESHLINK_ERROR, "Could not write main config files into %s/current: %s\n", mesh->confbase, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; return false; } @@ -902,7 +908,7 @@ static bool meshlink_read_config(meshlink_handle_t *mesh) { config_t config; - if(!main_config_read(mesh, &config)) { + if(!main_config_read(mesh, "current", &config, mesh->config_key)) { logger(NULL, MESHLINK_ERROR, "Could not read main configuration file!"); return false; } @@ -1222,7 +1228,7 @@ meshlink_handle_t *meshlink_open_ex(const meshlink_open_params_t *params) { // If no configuration exists yet, create it. - if(!main_config_exists(mesh)) { + if(!meshlink_confbase_exists(mesh)) { if(!meshlink_setup(mesh)) { logger(NULL, MESHLINK_ERROR, "Cannot create initial configuration\n"); meshlink_close(mesh); @@ -1524,7 +1530,21 @@ bool meshlink_destroy(const char *confbase) { return false; } - return config_destroy(confbase); + if(!config_destroy(confbase, "current")) { + logger(NULL, MESHLINK_ERROR, "Cannot remove confbase sub-directories %s: %s\n", confbase, strerror(errno)); + return false; + } + + config_destroy(confbase, "new"); + config_destroy(confbase, "old"); + + if(rmdir(confbase) && errno != ENOENT) { + logger(NULL, MESHLINK_ERROR, "Cannot remove directory %s: %s\n", confbase, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + + return true; } void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) { @@ -1815,7 +1835,7 @@ static meshlink_node_t **meshlink_get_all_nodes_by_condition(meshlink_handle_t * static bool search_node_by_dev_class(const node_t *node, const void *condition) { dev_class_t *devclass = (dev_class_t *)condition; - if(*devclass == node->devclass) { + if(*devclass == (dev_class_t)node->devclass) { return true; } @@ -2059,6 +2079,7 @@ bool meshlink_set_port(meshlink_handle_t *mesh, int port) { mesh->self = new_node(); mesh->self->name = xstrdup(mesh->name); mesh->self->devclass = mesh->devclass; + xasprintf(&mesh->myport, "%d", port); if(!node_read_public_key(mesh, mesh->self)) { logger(NULL, MESHLINK_ERROR, "Could not read our host configuration file!"); @@ -2112,7 +2133,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c } // Ensure no host configuration file with that name exists - if(config_exists(mesh, name)) { + if(config_exists(mesh, "current", name)) { logger(mesh, MESHLINK_DEBUG, "A host config file for %s already exists!\n", name); meshlink_errno = MESHLINK_EEXIST; pthread_mutex_unlock(&(mesh->mesh_mutex)); @@ -2182,7 +2203,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c config_t configs[5] = {NULL}; int count = 0; - if(config_read(mesh, mesh->self->name, &configs[count])) { + if(config_read(mesh, "current", mesh->self->name, &configs[count], mesh->config_key)) { count++; } @@ -2196,7 +2217,7 @@ char *meshlink_invite_ex(meshlink_handle_t *mesh, meshlink_submesh_t *submesh, c config_t config = {outbuf, packmsg_output_size(&inv, outbuf)}; - if(!invitation_write(mesh, cookiehash, &config)) { + if(!invitation_write(mesh, "current", cookiehash, &config, mesh->config_key)) { logger(mesh, MESHLINK_DEBUG, "Could not create invitation file %s: %s\n", cookiehash, strerror(errno)); meshlink_errno = MESHLINK_ESTORAGE; pthread_mutex_unlock(&(mesh->mesh_mutex)); @@ -2590,7 +2611,7 @@ bool meshlink_import(meshlink_handle_t *mesh, const char *data) { break; } - config_write(mesh, n->name, &config); + config_write(mesh, "current", n->name, &config, mesh->config_key); node_add(mesh, n); } diff --git a/src/meshlink.h b/src/meshlink.h index 6a1c758a..c8c47184 100644 --- a/src/meshlink.h +++ b/src/meshlink.h @@ -1187,7 +1187,7 @@ extern void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable); * * @return This function returns true if the key rotation for the encrypted storage succeeds, false otherwise. */ -extern bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, size_t new_keylen); +extern bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const char *new_key, size_t new_keylen); #ifdef __cplusplus } diff --git a/src/net_setup.c b/src/net_setup.c index 64088b3a..52f5e820 100644 --- a/src/net_setup.c +++ b/src/net_setup.c @@ -36,7 +36,7 @@ /// Helper function to start parsing a host config file static bool node_get_config(meshlink_handle_t *mesh, node_t *n, config_t *config, packmsg_input_t *in) { - if(!config_read(mesh, n->name, config)) { + if(!config_read(mesh, "current", n->name, config, mesh->config_key)) { return false; } @@ -228,6 +228,10 @@ bool node_read_from_config(meshlink_handle_t *mesh, node_t *n, const config_t *c } bool node_write_config(meshlink_handle_t *mesh, node_t *n) { + if(!mesh->confbase) { + return true; + } + uint8_t buf[4096]; packmsg_output_t out = {buf, sizeof(buf)}; @@ -266,18 +270,20 @@ bool node_write_config(meshlink_handle_t *mesh, node_t *n) { } config_t config = {buf, packmsg_output_size(&out, buf)}; - return config_write(mesh, n->name, &config); + return config_write(mesh, "current", n->name, &config, mesh->config_key); } -static void load_node(meshlink_handle_t *mesh, const char *name) { +static bool load_node(meshlink_handle_t *mesh, const char *name, void *priv) { + (void)priv; + if(!check_id(name)) { - return; + return true; } node_t *n = lookup_node(mesh, name); if(n) { - return; + return true; } n = new_node(); @@ -285,10 +291,12 @@ static void load_node(meshlink_handle_t *mesh, const char *name) { if(!node_read_partial(mesh, n)) { free_node(n); - return; + return true; } node_add(mesh, n); + + return true; } /* @@ -403,7 +411,7 @@ bool setup_myself(meshlink_handle_t *mesh) { graph(mesh); - config_scan_all(mesh, load_node); + config_scan_all(mesh, "current", "hosts", load_node, NULL); /* Open sockets */ diff --git a/src/protocol_auth.c b/src/protocol_auth.c index d26b0f65..e2fe28b4 100644 --- a/src/protocol_auth.c +++ b/src/protocol_auth.c @@ -205,7 +205,7 @@ static bool receive_invitation_sptps(void *handle, uint8_t type, const void *dat config_t config; - if(!invitation_read(mesh, cookie, &config)) { + if(!invitation_read(mesh, "current", cookie, &config, mesh->config_key)) { logger(mesh, MESHLINK_ERROR, "Error while trying to read invitation file\n"); return false; } @@ -238,6 +238,9 @@ static bool receive_invitation_sptps(void *handle, uint8_t type, const void *dat // Send the node the contents of the invitation file sptps_send_record(&c->sptps, 0, config.buf, config.len); + config_free(&config); + free(submesh_name); + c->status.invitation_used = true; logger(mesh, MESHLINK_INFO, "Invitation %s successfully sent to %s", cookie, c->name); -- 2.39.5