X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;ds=sidebyside;f=src%2Fconf.c;h=803c96c219d38621e5f449bb89d6e01cde232f91;hb=fa05f996c5500c056a36c1d43e33a407f876643c;hp=3bf9b85f602ca815e77f4d2d86ec1a6498bbfd75;hpb=c2b9c06062d36bde859b630b99a08c7b7428e721;p=meshlink diff --git a/src/conf.c b/src/conf.c index 3bf9b85f..9e93c9a1 100644 --- a/src/conf.c +++ b/src/conf.c @@ -1,9 +1,6 @@ /* - conf.c -- configuration code - Copyright (C) 1998 Robert van der Meulen - 1998-2002 Ivo Timmermans - 2000-2002 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,609 +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.53 2002/02/18 16:25:16 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 "config.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include /* for cp */ -#include +#include "system.h" +#include #include "conf.h" -#include "netutl.h" /* for str2address */ +#include "crypto.h" +#include "logger.h" +#include "meshlink_internal.h" +#include "xalloc.h" +#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); +} -#include "system.h" +/// 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); +} -avl_tree_t *config_tree; +/// 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); +} -int debug_lvl = 0; -int pingtimeout = 0; /* seconds before timeout */ -char *confbase = NULL; /* directory in which all config files are */ -char *netname = NULL; /* name of the vpn network */ +/// 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); +} -int config_compare(config_t *a, config_t *b) -{ - int result; +/// Remove a directory recursively +static void deltree(const char *dirname) { + DIR *d = opendir(dirname); - result = strcasecmp(a->variable, b->variable); + if(d) { + struct dirent *ent; - if(result) - return result; + while((ent = readdir(d))) { + if(ent->d_name[0] == '.') { + continue; + } - result = a->line - b->line; + char filename[PATH_MAX]; + snprintf(filename, sizeof(filename), "%s" SLASH "%s", dirname, ent->d_name); - if(result) - return result; - else - return strcmp(a->file, b->file); -} + if(unlink(filename)) { + deltree(filename); + } + } -void init_configuration(avl_tree_t **config_tree) -{ -cp - *config_tree = avl_alloc_tree((avl_compare_t)config_compare, (avl_action_t)free_config); -cp -} + closedir(d); + } -void exit_configuration(avl_tree_t **config_tree) -{ -cp - avl_delete_tree(*config_tree); - *config_tree = NULL; -cp + rmdir(dirname); } -config_t *new_config(void) -{ - config_t *cfg; -cp - cfg = (config_t *)xmalloc_and_zero(sizeof(*cfg)); +/// 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; + } + + 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; + } + + // 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; + } - return cfg; + return true; } -void free_config(config_t *cfg) -{ -cp - if(cfg->variable) - free(cfg->variable); - if(cfg->value) - free(cfg->value); - if(cfg->file) - free(cfg->file); - free(cfg); -cp +/// 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; + } + } + + deltree(confbase); + return true; } -void config_add(avl_tree_t *config_tree, config_t *cfg) -{ -cp - avl_insert(config_tree, cfg); -cp +/// 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; } -config_t *lookup_config(avl_tree_t *config_tree, char *variable) -{ - config_t cfg, *found; -cp - cfg.variable = variable; - cfg.file = ""; - cfg.line = 0; +/// Lock the main configuration file. +bool main_config_lock(meshlink_handle_t *mesh) { + char path[PATH_MAX]; + make_main_path(mesh, path, sizeof(path)); - found = avl_search_closest_greater(config_tree, &cfg); + mesh->conffile = fopen(path, "r"); - if(!found) - return NULL; + if(!mesh->conffile) { + logger(NULL, MESHLINK_ERROR, "Cannot not open %s: %s\n", path, strerror(errno)); + meshlink_errno = MESHLINK_ESTORAGE; + return false; + } - if(strcmp(found->variable, variable)) - return NULL; +#ifdef FD_CLOEXEC + fcntl(fileno(mesh->conffile), F_SETFD, FD_CLOEXEC); +#endif - return found; -} +#ifdef HAVE_MINGW + // TODO: use _locking()? +#else -config_t *lookup_config_next(avl_tree_t *config_tree, config_t *cfg) -{ - avl_node_t *node; - config_t *found; -cp - node = avl_search_node(config_tree, cfg); - - if(node) - { - if(node->next) - { - found = (config_t *)node->next->data; - if(!strcmp(found->variable, cfg->variable)) - return found; - } - } - - return NULL; + 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; } -int get_config_bool(config_t *cfg, int *result) -{ -cp - if(!cfg) - return 0; - - if(!strcasecmp(cfg->value, "yes")) - { - *result = 1; - return 1; - } - else if(!strcasecmp(cfg->value, "no")) - { - *result = 0; - return 1; - } - - syslog(LOG_ERR, _("\"yes\" or \"no\" expected for configuration variable %s in %s line %d"), - cfg->variable, cfg->file, cfg->line); - - return 0; +/// Unlock the main configuration file. +void main_config_unlock(meshlink_handle_t *mesh) { + if(mesh->conffile) { + fclose(mesh->conffile); + mesh->conffile = NULL; + } } -int get_config_int(config_t *cfg, int *result) -{ -cp - if(!cfg) - return 0; +/// 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(sscanf(cfg->value, "%d", result) == 1) - return 1; + 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; + } - syslog(LOG_ERR, _("Integer expected for configuration variable %s in %s line %d"), - cfg->variable, cfg->file, cfg->line); - return 0; -} + uint8_t *buf = xmalloc(len); -int get_config_string(config_t *cfg, char **result) -{ -cp - if(!cfg) - return 0; + 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; + } - *result = xstrdup(cfg->value); - return 1; -} + 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; + } + } -int get_config_address(config_t *cfg, struct addrinfo **result) -{ - struct addrinfo *ai; -cp - if(!cfg) - return 0; + config->buf = buf; + config->len = len; - ai = str2addrinfo(cfg->value, NULL, 0); + 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(ai) - { - *result = ai; - return 1; - } + 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; + } - syslog(LOG_ERR, _("Hostname or IP address expected for configuration variable %s in %s line %d"), - cfg->variable, cfg->file, cfg->line); - return 0; + return true; } -int get_config_port(config_t *cfg, port_t *result) -{ -cp - if(!cfg) - return 0; - - if(sscanf(cfg->value, "%hu", result) == 1) - { - *result = htons(*result); - return 1; - } - - syslog(LOG_ERR, _("Port number expected for configuration variable %s in %s line %d"), - cfg->variable, cfg->file, cfg->line); - return 0; +/// Free resources of a loaded configuration file. +void config_free(config_t *config) { + free((uint8_t *)config->buf); + config->buf = NULL; + config->len = 0; } -int get_config_subnet(config_t *cfg, subnet_t **result) -{ - subnet_t *subnet; -cp - if(!cfg) - return 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)); - subnet = str2net(cfg->value); + return access(path, F_OK) == 0; +} - if(!subnet) - { - syslog(LOG_ERR, _("Subnet expected for configuration variable %s in %s line %d"), - cfg->variable, cfg->file, cfg->line); - return 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)); - /* Teach newbies what subnets are... */ + FILE *f = fopen(path, "r"); - if(((subnet->type == SUBNET_IPV4) && maskcheck((char *)&subnet->net.ipv4.address, subnet->net.ipv4.masklength, sizeof(ipv4_t))) - || ((subnet->type == SUBNET_IPV6) && maskcheck((char *)&subnet->net.ipv6.address, subnet->net.ipv6.masklength, sizeof(ipv6_t)))) - { - syslog(LOG_ERR, _("Network address and mask length do not match for configuration variable %s in %s line %d"), - cfg->variable, cfg->file, cfg->line); - free(subnet); - return 0; - } + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } - *result = subnet; + if(!config_read_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno)); + fclose(f); + return false; + } - return 1; + fclose(f); + return true; } -/* - Read exactly one line and strip the trailing newline if any. If the - file was on EOF, return NULL. Otherwise, return all the data in a - dynamically allocated buffer. - - If line is non-NULL, it will be used as an initial buffer, to avoid - unnecessary mallocing each time this function is called. If buf is - given, and buf needs to be expanded, the var pointed to by buflen - will be increased. -*/ -char *readline(FILE *fp, char **buf, size_t *buflen) -{ - char *newline = NULL; - char *p; - char *line; /* The array that contains everything that has been read - so far */ - char *idx; /* Read into this pointer, which points to an offset - within line */ - size_t size, newsize; /* The size of the current array pointed to by - line */ - size_t maxlen; /* Maximum number of characters that may be read with - fgets. This is newsize - oldsize. */ - - if(feof(fp)) - return NULL; - - if((buf != NULL) && (buflen != NULL)) - { - size = *buflen; - line = *buf; - } - else - { - size = 100; - line = xmalloc(size); - } - - maxlen = size; - idx = line; - *idx = 0; - for(;;) - { - errno = 0; - p = fgets(idx, maxlen, fp); - if(p == NULL) /* EOF or error */ - { - if(feof(fp)) - break; - - /* otherwise: error; let the calling function print an error - message if applicable */ - free(line); - return NULL; +/// 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; } - newline = strchr(p, '\n'); - if(newline == NULL) - /* We haven't yet read everything to the end of the line */ - { - newsize = size << 1; - line = xrealloc(line, newsize); - idx = &line[size - 1]; - maxlen = newsize - size + 1; - size = newsize; + if(!config_write_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); + fclose(f); + return false; } - else - { - *newline = '\0'; /* kill newline */ - break; /* yay */ + + 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((buf != NULL) && (buflen != NULL)) - { - *buflen = size; - *buf = line; - } - return line; + + 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; } -/* - Parse a configuration file and put the results in the configuration tree - starting at *base. -*/ -int read_config_file(avl_tree_t *config_tree, const char *fname) -{ - int err = -2; /* Parse error */ - FILE *fp; - char *buffer, *line; - char *variable, *value; - int lineno = 0, ignore = 0; - config_t *cfg; - size_t bufsize; - -cp - if((fp = fopen (fname, "r")) == NULL) - { - syslog(LOG_ERR, _("Cannot open config file %s: %s"), fname, strerror(errno)); - return -3; - } - - bufsize = 100; - buffer = xmalloc(bufsize); - - for(;;) - { - if((line = readline(fp, &buffer, &bufsize)) == NULL) - { - err = -1; - break; +/// 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(feof(fp)) - { - err = 0; - break; + if(!config_write_file(mesh, f, config)) { + logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno)); + fclose(f); + return false; } - lineno++; + fclose(f); + return true; +} - if((variable = strtok(line, "\t =")) == NULL) - continue; /* no tokens on this line */ +/// 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; + } - if(variable[0] == '#') - continue; /* comment: ignore */ + FILE *f = fopen(used_path, "r"); - if(!strcmp(variable, "-----BEGIN")) - ignore = 1; + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } - if(!ignore) - { - if(((value = strtok(NULL, "\t\n\r =")) == NULL) || value[0] == '#') - { - syslog(LOG_ERR, _("No value for variable `%s' on line %d while reading config file %s"), - variable, lineno, fname); - break; - } + // Check the timestamp + struct stat st; - cfg = new_config(); - cfg->variable = xstrdup(variable); - cfg->value = xstrdup(value); - cfg->file = xstrdup(fname); - cfg->line = lineno; + if(fstat(fileno(f), &st)) { + logger(mesh, MESHLINK_ERROR, "Could not stat invitation file %s\n", name); + fclose(f); + unlink(used_path); + return false; + } - config_add(config_tree, cfg); - } + 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(!strcmp(variable, "-----END")) - ignore = 0; - } + 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; + } - free(buffer); - fclose (fp); -cp - return err; + fclose(f); + unlink(used_path); + return true; } -int read_server_config() -{ - char *fname; - int x; -cp - asprintf(&fname, "%s/tinc.conf", confbase); - x = read_config_file(config_tree, fname); - if(x == -1) /* System error: complain */ - { - syslog(LOG_ERR, _("Failed to read `%s': %s"), fname, strerror(errno)); - } - free(fname); -cp - return x; -} +/// 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)); -int isadir(const char* f) -{ - struct stat s; + FILE *f = fopen(path, "w"); - if(stat(f, &s) < 0) - return 0; - else - return S_ISDIR(s.st_mode); -} + if(!f) { + logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno)); + return false; + } -int is_safe_path(const char *file) -{ - char *p; - const char *f; - char x; - struct stat s; - char l[MAXBUFSIZE]; - - if(*file != '/') - { - syslog(LOG_ERR, _("`%s' is not an absolute path"), file); - return 0; - } - - p = strrchr(file, '/'); - - if(p == file) /* It's in the root */ - p++; - - x = *p; - *p = '\0'; - - f = file; -check1: - if(lstat(f, &s) < 0) - { - syslog(LOG_ERR, _("Couldn't stat `%s': %s"), f, strerror(errno)); - return 0; - } - - if(s.st_uid != geteuid()) - { - syslog(LOG_ERR, _("`%s' is owned by UID %d instead of %d"), - f, s.st_uid, geteuid()); - return 0; - } - - if(S_ISLNK(s.st_mode)) - { - syslog(LOG_WARNING, _("Warning: `%s' is a symlink"), - f); - - if(readlink(f, l, MAXBUFSIZE) < 0) - { - syslog(LOG_ERR, _("Unable to read symbolic link `%s': %s"), f, strerror(errno)); - return 0; - } - - f = l; - goto check1; - } - - *p = x; - f = file; - -check2: - if(lstat(f, &s) < 0 && errno != ENOENT) - { - syslog(LOG_ERR, _("Couldn't stat `%s': %s"), f, strerror(errno)); - return 0; - } - - if(errno == ENOENT) - return 1; - - if(s.st_uid != geteuid()) - { - syslog(LOG_ERR, _("`%s' is owned by UID %d instead of %d"), - f, s.st_uid, geteuid()); - return 0; - } - - if(S_ISLNK(s.st_mode)) - { - syslog(LOG_WARNING, _("Warning: `%s' is a symlink"), - f); - - if(readlink(f, l, MAXBUFSIZE) < 0) - { - syslog(LOG_ERR, _("Unable to read symbolic link `%s': %s"), f, strerror(errno)); - return 0; - } - - f = l; - goto check2; - } - - if(s.st_mode & 0007) - { - /* Accessible by others */ - syslog(LOG_ERR, _("`%s' has unsecure permissions"), - f); - return 0; - } - - return 1; + 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; } -FILE *ask_and_safe_open(const char* filename, const char* what, const char* mode) -{ - FILE *r; - char *directory; - char *fn; - - /* Check stdin and stdout */ - if(!isatty(0) || !isatty(1)) - { - /* Argh, they are running us from a script or something. Write - the files to the current directory and let them burn in hell - for ever. */ - fn = xstrdup(filename); - } - else - { - /* Ask for a file and/or directory name. */ - fprintf(stdout, _("Please enter a file to save %s to [%s]: "), - what, filename); - fflush(stdout); - - if((fn = readline(stdin, NULL, NULL)) == NULL) - { - fprintf(stderr, _("Error while reading stdin: %s\n"), strerror(errno)); - return NULL; +/// 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; } - if(strlen(fn) == 0) - /* User just pressed enter. */ - fn = xstrdup(filename); - } - - if((strchr(fn, '/') == NULL) || (fn[0] != '/')) - { - /* The directory is a relative path or a filename. */ - char *p; - - directory = get_current_dir_name(); - asprintf(&p, "%s/%s", directory, fn); - free(fn); - free(directory); - fn = p; - } - - umask(0077); /* Disallow everything for group and other */ - - /* Open it first to keep the inode busy */ - if((r = fopen(fn, mode)) == NULL) - { - fprintf(stderr, _("Error opening file `%s': %s\n"), - fn, strerror(errno)); - free(fn); - return NULL; - } - - /* Then check the file for nasty attacks */ - if(!is_safe_path(fn)) /* Do not permit any directories that are - readable or writeable by other users. */ - { - fprintf(stderr, _("The file `%s' (or any of the leading directories) has unsafe permissions.\n" - "I will not create or overwrite this file.\n"), - fn); - fclose(r); - free(fn); - return NULL; - } - - free(fn); - - return r; + 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; }