X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fconf.c;h=803c96c219d38621e5f449bb89d6e01cde232f91;hb=fa05f996c5500c056a36c1d43e33a407f876643c;hp=640ec1357d69bd89e171560bf8c317fe188a137a;hpb=6e39481d8f2406e60b5e329ace08b5a005d5cc43;p=meshlink diff --git a/src/conf.c b/src/conf.c index 640ec135..9e93c9a1 100644 --- a/src/conf.c +++ b/src/conf.c @@ -1,9 +1,6 @@ /* - conf.c -- configuration code - Copyright (C) 1998 Emphyrio, - Copyright (C) 1998,1999,2000 Ivo Timmermans - 2000 Guus Sliepen - 2000 Cris van Pelt + econf.c -- configuration code + Copyright (C) 2018 Guus Sliepen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,246 +12,480 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - $Id: conf.c,v 1.9.4.11 2000/10/11 13:42:52 guus Exp $ + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include "system.h" +#include -#include "config.h" +#include "conf.h" +#include "crypto.h" +#include "logger.h" +#include "meshlink_internal.h" +#include "xalloc.h" +#include "packmsg.h" -#include -#include -#include -#include -#include -#include +/// 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); +} -#include +/// 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); +} -#include "conf.h" -#include "netutl.h" /* for strtoip */ -#include /* for cp */ +/// 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); +} -#include "system.h" +/// 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); +} -config_t *config; -int debug_lvl = 0; -int timeout = 0; /* seconds before timeout */ -char *configfilename = NULL; +/// Remove a directory recursively +static void deltree(const char *dirname) { + DIR *d = opendir(dirname); -/* Will be set if HUP signal is received. It will be processed when it is safe. */ -int sighup = 0; + if(d) { + struct dirent *ent; -/* - These are all the possible configurable values -*/ -static internal_config_t hazahaza[] = { -/* Main configuration file keywords */ - { "Name", tincname, TYPE_NAME }, - { "ConnectTo", connectto, TYPE_NAME }, - { "PingTimeout", pingtimeout, TYPE_INT }, - { "TapDevice", tapdevice, TYPE_NAME }, - { "PrivateKey", privatekey, TYPE_NAME }, - { "KeyExpire", keyexpire, TYPE_INT }, - { "Hostnames", resolve_dns, TYPE_BOOL }, - { "Interface", interface, TYPE_NAME }, - { "InterfaceIP", interfaceip, TYPE_IP }, -/* Host configuration file keywords */ - { "Address", address, TYPE_NAME }, - { "Port", port, TYPE_INT }, - { "PublicKey", publickey, TYPE_NAME }, - { "Subnet", subnet, TYPE_NAME }, - { "RestrictHosts", restricthosts, TYPE_BOOL }, - { "RestrictSubnets", restrictsubnets, TYPE_BOOL }, - { "RestrictAddress", restrictaddress, TYPE_BOOL }, - { "RestrictPort", restrictport, TYPE_BOOL }, - { "IndirectData", indirectdata, TYPE_BOOL }, - { "TCPonly", tcponly, TYPE_BOOL }, - { NULL, 0, 0 } -}; + while((ent = readdir(d))) { + if(ent->d_name[0] == '.') { + continue; + } -/* - Add given value to the list of configs cfg -*/ -config_t * -add_config_val(config_t **cfg, int argtype, char *val) -{ - config_t *p, *r; - char *q; -cp - p = (config_t*)xmalloc(sizeof(*p)); - p->data.val = 0; - - switch(argtype) - { - case TYPE_INT: - p->data.val = strtol(val, &q, 0); - if(q && *q) - p->data.val = 0; - break; - case TYPE_NAME: - p->data.ptr = xmalloc(strlen(val) + 1); - strcpy(p->data.ptr, val); - break; - case TYPE_IP: - p->data.ip = strtoip(val); - break; - case TYPE_BOOL: - if(!strcasecmp("yes", val)) - p->data.val = stupid_true; - else if(!strcasecmp("no", val)) - p->data.val = stupid_false; - else - p->data.val = 0; - } - - p->argtype = argtype; - - if(p->data.val) - { - if(*cfg) - { - r = *cfg; - while(r->next) - r = r->next; - r->next = p; - } - else - *cfg = p; - p->next = NULL; - return p; - } - - free(p); -cp - return NULL; + char filename[PATH_MAX]; + snprintf(filename, sizeof(filename), "%s" SLASH "%s", dirname, ent->d_name); + + if(unlink(filename)) { + deltree(filename); + } + } + + closedir(d); + } + + rmdir(dirname); } -/* - Parse a configuration file and put the results in the configuration tree - starting at *base. -*/ -int read_config_file(config_t **base, const char *fname) -{ - int err; - FILE *fp; - char line[MAXBUFSIZE]; /* There really should not be any line longer than this... */ - char *p, *q; - int i, err = -1, lineno = 0; - config_t *cfg; -cp - if((fp = fopen (fname, "r")) == NULL) - { - return -1; - } - - for(;;) - { - if(fgets(line, MAXBUFSIZE, fp) == NULL) - { - err = 0; - break; - } - - lineno++; - - if(!index(line, '\n')) - { - syslog(LOG_ERR, _("Line %d too long while reading config file %s"), lineno, fname); - break; - } - - if((p = strtok(line, "\t\n\r =")) == NULL) - continue; /* no tokens on this line */ - - if(p[0] == '#') - continue; /* comment: ignore */ - - for(i = 0; hazahaza[i].name != NULL; i++) - if(!strcasecmp(hazahaza[i].name, p)) - break; - - if(!hazahaza[i].name) - { - syslog(LOG_ERR, _("Invalid variable name on line %d while reading config file %s"), - lineno, fname); - break; +/// Create a fresh configuration directory +bool config_init(meshlink_handle_t *mesh) { + if(mkdir(mesh->confbase, 0700) && errno != EEXIST) { + logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", mesh->confbase, strerror(errno)); + return false; } - if(((q = strtok(NULL, "\t\n\r =")) == NULL) || q[0] == '#') - { - fprintf(stderr, _("No value for variable on line %d while reading config file %s"), - lineno, fname); - break; + 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); + deltree(path); + + if(mkdir(path, 0700) && errno != EEXIST) { + logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno)); + return false; } - cfg = add_config_val(base, hazahaza[i].argtype, q); - if(cfg == NULL) - { - fprintf(stderr, _("Invalid value for variable on line %d while reading config file %s"), - lineno, fname); - break; + // Remove any invitation files + snprintf(path, sizeof(path), "%s" SLASH "invitations", mesh->confbase); + deltree(path); + + if(mkdir(path, 0700) && errno != EEXIST) { + logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno)); + return false; } - cfg->which = hazahaza[i].which; - if(!config) - config = cfg; - } + return true; +} + +/// Wipe an existing configuration directory +bool config_destroy(const char *confbase) { + char path[PATH_MAX]; + + // Remove meshlink.conf + snprintf(path, sizeof(path), "%s" SLASH "meshlink.conf", confbase); + + if(unlink(path)) { + if(errno == ENOENT) { + meshlink_errno = MESHLINK_ENOENT; + return false; + } else { + logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", path, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + } - fclose (fp); -cp - return err; + deltree(confbase); + return true; } -/* - Look up the value of the config option type -*/ -const config_t *get_config_val(config_t *p, which_t type) -{ -cp - for(p = config; p != NULL; p = p->next) - if(p->which == type) - return p; -cp - /* Not found */ - return NULL; +/// Check the presence of the main configuration file. +bool main_config_exists(meshlink_handle_t *mesh) { + char path[PATH_MAX]; + make_main_path(mesh, path, sizeof(path)); + + return access(path, F_OK) == 0; } -/* - Support for multiple config lines. - Index is used to get a specific value, 0 being the first, 1 the second etc. -*/ -const config_t *get_next_config_val(config_t *p, which_t type, int index) -{ -cp - for(p = config; p != NULL; p = p->next) - if(p->which == type) - if(--index < 0) - return p; -cp - /* Not found */ - return NULL; +/// Lock the main configuration file. +bool main_config_lock(meshlink_handle_t *mesh) { + char path[PATH_MAX]; + make_main_path(mesh, path, sizeof(path)); + + mesh->conffile = fopen(path, "r"); + + if(!mesh->conffile) { + logger(NULL, MESHLINK_ERROR, "Cannot not open %s: %s\n", path, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + +#ifdef FD_CLOEXEC + fcntl(fileno(mesh->conffile), F_SETFD, FD_CLOEXEC); +#endif + +#ifdef HAVE_MINGW + // TODO: use _locking()? +#else + + if(flock(fileno(mesh->conffile), LOCK_EX | LOCK_NB) != 0) { + logger(NULL, MESHLINK_ERROR, "Cannot lock %s: %s\n", path, strerror(errno)); + fclose(mesh->conffile); + mesh->conffile = NULL; + meshlink_errno = MESHLINK_EBUSY; + return false; + } + +#endif + + return true; } -/* - Remove the complete configuration tree. -*/ -void clear_config(config_t **base) -{ - config_t *p, *next; -cp - for(p = *base; p != NULL; p = next) - { - next = p->next; - if(p->data.ptr && (p->argtype == TYPE_NAME)) - { - free(p->data.ptr); - } - free(p); - } - *base = NULL; -cp +/// Unlock the main configuration file. +void main_config_unlock(meshlink_handle_t *mesh) { + if(mesh->conffile) { + fclose(mesh->conffile); + mesh->conffile = NULL; + } +} + +/// Read a configuration file from a FILE handle. +bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config) { + (void)mesh; + long len; + + if(fseek(f, 0, SEEK_END) || !(len = ftell(f)) || fseek(f, 0, SEEK_SET)) { + logger(mesh, MESHLINK_ERROR, "Cannot get config file size: %s\n", strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + fclose(f); + return false; + } + + uint8_t *buf = xmalloc(len); + + if(fread(buf, len, 1, f) != 1) { + logger(mesh, MESHLINK_ERROR, "Cannot read config file: %s\n", strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + fclose(f); + return false; + } + + if(mesh->config_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); + + if(len > 12 && chacha_poly1305_decrypt_iv96(ctx, buf, buf + 12, len - 12, decrypted, &decrypted_len)) { + free(buf); + config->buf = decrypted; + config->len = decrypted_len; + return true; + } else { + logger(mesh, MESHLINK_ERROR, "Cannot decrypt config file\n"); + meshlink_errno = MESHLINK_ESTORAGE; + free(decrypted); + free(buf); + return false; + } + } + + config->buf = buf; + config->len = len; + + return true; +} + +/// Write a configuration file to a FILE handle. +bool config_write_file(meshlink_handle_t *mesh, FILE *f, const config_t *config) { + if(mesh->config_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); + bool success = false; + + if(chacha_poly1305_encrypt_iv96(ctx, seqbuf, config->buf, config->len, buf, &len)) { + success = fwrite(seqbuf, sizeof(seqbuf), 1, f) == 1 && fwrite(buf, len, 1, f) == 1; + } else { + logger(mesh, MESHLINK_ERROR, "Cannot encrypt config file\n"); + meshlink_errno = MESHLINK_ESTORAGE; + } + + chacha_poly1305_exit(ctx); + return success; + } + + if(fwrite(config->buf, config->len, 1, f) != 1) { + logger(mesh, MESHLINK_ERROR, "Cannot write config file: %s", strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } + + return true; +} + +/// Free resources of a loaded configuration file. +void config_free(config_t *config) { + free((uint8_t *)config->buf); + config->buf = NULL; + config->len = 0; +} + +/// Check the presence of a host configuration file. +bool config_exists(meshlink_handle_t *mesh, const char *name) { + char path[PATH_MAX]; + make_host_path(mesh, 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) { + char path[PATH_MAX]; + make_host_path(mesh, name, path, sizeof(path)); + + FILE *f = fopen(path, "r"); + + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } + + if(!config_read_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); + fclose(f); + return false; + } + + fclose(f); + return true; +} + +/// Write a host configuration file. +bool config_write(meshlink_handle_t *mesh, const char *name, const config_t *config) { + char path[PATH_MAX]; + make_host_path(mesh, name, path, sizeof(path)); + + FILE *f = fopen(path, "w"); + + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } + + if(!config_write_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); + fclose(f); + return false; + } + + fclose(f); + return true; +} + +/// Read the main configuration file. +bool main_config_read(meshlink_handle_t *mesh, config_t *config) { + char path[PATH_MAX]; + make_main_path(mesh, path, sizeof(path)); + + FILE *f = fopen(path, "r"); + + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } + + if(!config_read_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); + fclose(f); + return false; + } + + fclose(f); + return true; +} + +/// Write the main configuration file. +bool main_config_write(meshlink_handle_t *mesh, const config_t *config) { + char path[PATH_MAX]; + make_main_path(mesh, path, sizeof(path)); + + FILE *f = fopen(path, "w"); + + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } + + if(!config_write_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); + fclose(f); + return false; + } + + fclose(f); + return true; +} + +/// Read an invitation file, and immediately delete it. +bool invitation_read(meshlink_handle_t *mesh, const char *name, config_t *config) { + 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)); + + // Atomically rename the invitation file + if(rename(path, used_path)) { + if(errno == ENOENT) { + logger(mesh, MESHLINK_ERROR, "Peer tried to use non-existing invitation %s\n", name); + } else { + logger(mesh, MESHLINK_ERROR, "Error trying to rename invitation %s\n", name); + } + + return false; + } + + FILE *f = fopen(used_path, "r"); + + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } + + // Check the timestamp + struct stat st; + + if(fstat(fileno(f), &st)) { + logger(mesh, MESHLINK_ERROR, "Could not stat invitation file %s\n", name); + fclose(f); + unlink(used_path); + return false; + } + + if(time(NULL) > st.st_mtime + mesh->invitation_timeout) { + logger(mesh, MESHLINK_ERROR, "Peer tried to use an outdated invitation file %s\n", name); + fclose(f); + unlink(used_path); + return false; + } + + if(!config_read_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); + fclose(f); + unlink(used_path); + return false; + } + + fclose(f); + unlink(used_path); + return true; +} + +/// Write an invitation file. +bool invitation_write(meshlink_handle_t *mesh, const char *name, const config_t *config) { + char path[PATH_MAX]; + make_invitation_path(mesh, name, path, sizeof(path)); + + FILE *f = fopen(path, "w"); + + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } + + if(!config_write_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); + fclose(f); + return false; + } + + fclose(f); + return true; +} + +/// Purge old invitation files +size_t invitation_purge_old(meshlink_handle_t *mesh, time_t deadline) { + char path[PATH_MAX]; + make_invitation_path(mesh, "", path, sizeof(path)); + + DIR *dir = opendir(path); + + if(!dir) { + logger(mesh, MESHLINK_DEBUG, "Could not read directory %s: %s\n", path, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return 0; + } + + errno = 0; + size_t count = 0; + struct dirent *ent; + + while((ent = readdir(dir))) { + if(strlen(ent->d_name) != 24) { + continue; + } + + char invname[PATH_MAX]; + struct stat st; + + if(snprintf(invname, sizeof(invname), "%s" SLASH "%s", path, ent->d_name) >= PATH_MAX) { + logger(mesh, MESHLINK_DEBUG, "Filename too long: %s" SLASH "%s", path, ent->d_name); + continue; + } + + if(!stat(invname, &st)) { + if(mesh->invitation_key && deadline < st.st_mtime) { + count++; + } else { + unlink(invname); + } + } else { + logger(mesh, MESHLINK_DEBUG, "Could not stat %s: %s\n", invname, strerror(errno)); + errno = 0; + } + } + + if(errno) { + logger(mesh, MESHLINK_DEBUG, "Error while reading directory %s: %s\n", path, strerror(errno)); + closedir(dir); + meshlink_errno = MESHLINK_ESTORAGE; + return 0; + } + + closedir(dir); + + return count; }