X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=src%2Fconf.c;h=e3574ea5442888b3fa3edee6886040264f2378c5;hb=dd2cf09a9ac438b65a1f4c9dcff8d87a2b504538;hp=641ce3f87ad32a78a1b8261a890252607b95aa20;hpb=76d794eaf7c1664a47f4d0080fcd80e4a551740b;p=meshlink diff --git a/src/conf.c b/src/conf.c index 641ce3f8..e3574ea5 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 + Copyright (C) 2014 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,259 +12,517 @@ 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.16 2000/10/22 13:47:41 zarq 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 -#include -#include -#include -#include -#include -#include +#include "splay_tree.h" +#include "connection.h" +#include "conf.h" +#include "list.h" +#include "logger.h" +#include "meshlink_internal.h" +#include "netutl.h" /* for str2address */ +#include "protocol.h" +#include "utils.h" /* for cp */ +#include "xalloc.h" -#include +static int config_compare(const config_t *a, const config_t *b) { + int result; -#include "conf.h" -#include "netutl.h" /* for strtoip */ -#include /* for cp */ + result = strcasecmp(a->variable, b->variable); -#include "config.h" -#include "connlist.h" -#include "system.h" + if(result) { + return result; + } -config_t *config = NULL; -int debug_lvl = 0; -int timeout = 0; /* seconds before timeout */ -char *confbase = NULL; /* directory in which all config files are */ -char *netname = NULL; /* name of the vpn network */ + return result = a->line - b->line; +} -/* Will be set if HUP signal is received. It will be processed when it is safe. */ -int sighup = 0; +void init_configuration(splay_tree_t **config_tree) { + *config_tree = splay_alloc_tree((splay_compare_t) config_compare, (splay_action_t) free_config); +} -/* - 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 }, - { "TapSubnet", tapsubnet, TYPE_IP }, - { "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 } -}; +void exit_configuration(splay_tree_t **config_tree) { + if(*config_tree) { + splay_delete_tree(*config_tree); + } + + *config_tree = NULL; +} + +config_t *new_config(void) { + return xzalloc(sizeof(config_t)); +} + +void free_config(config_t *cfg) { + free(cfg->variable); + free(cfg->value); + free(cfg); +} + +void config_add(splay_tree_t *config_tree, config_t *cfg) { + splay_insert(config_tree, cfg); +} + +config_t *lookup_config(splay_tree_t *config_tree, char *variable) { + config_t cfg, *found; + + cfg.variable = variable; + cfg.line = 0; + + found = splay_search_closest_greater(config_tree, &cfg); + + if(!found) { + return NULL; + } + + if(strcasecmp(found->variable, variable)) { + return NULL; + } + + return found; +} + +config_t *lookup_config_next(splay_tree_t *config_tree, const config_t *cfg) { + splay_node_t *node; + config_t *found; + + node = splay_search_node(config_tree, cfg); + + if(node) { + if(node->next) { + found = node->next->data; + + if(!strcasecmp(found->variable, cfg->variable)) { + return found; + } + } + } + + return NULL; +} + +bool get_config_bool(const config_t *cfg, bool *result) { + if(!cfg) { + return false; + } + + if(!strcasecmp(cfg->value, "yes")) { + *result = true; + return true; + } else if(!strcasecmp(cfg->value, "no")) { + *result = false; + return true; + } + + logger(NULL, MESHLINK_ERROR, "\"yes\" or \"no\" expected for configuration variable %s in line %d", + cfg->variable, cfg->line); + + return false; +} + +bool get_config_int(const config_t *cfg, int *result) { + if(!cfg) { + return false; + } + + if(sscanf(cfg->value, "%d", result) == 1) { + return true; + } + + logger(NULL, MESHLINK_ERROR, "Integer expected for configuration variable %s in line %d", + cfg->variable, cfg->line); + + return false; +} + +bool set_config_int(config_t *cfg, int val) { + if(!cfg) { + return false; + } + + char val_str[1024]; + snprintf(val_str, sizeof(val_str), "%d", val); + + if(cfg->value) { + free(cfg->value); + } + + cfg->value = xstrdup(val_str); + + return true; +} + +bool get_config_string(const config_t *cfg, char **result) { + if(!cfg) { + return false; + } + + *result = xstrdup(cfg->value); + + return true; +} + +bool set_config_string(config_t *cfg, const char *val) { + if(!cfg) { + return false; + } + + if(cfg->value) { + free(cfg->value); + } + + cfg->value = xstrdup(val); + + return true; +} + +bool get_config_address(const config_t *cfg, struct addrinfo **result) { + struct addrinfo *ai; + + if(!cfg) { + return false; + } + + ai = str2addrinfo(cfg->value, NULL, 0); + + if(ai) { + *result = ai; + return true; + } + + logger(NULL, MESHLINK_ERROR, "Hostname or IP address expected for configuration variable %s in line %d", + cfg->variable, cfg->line); + + return false; +} /* - Add given value to the list of configs cfg + Read exactly one line and strip the trailing newline if any. */ -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) - { - p->next = *cfg; - *cfg = p; -cp - return p; - } - else - { - free(p); -cp - return NULL; - } +static char *readline(FILE *fp, char *buf, size_t buflen) { + char *newline = NULL; + char *p; + + if(feof(fp)) { + return NULL; + } + + p = fgets(buf, buflen, fp); + + if(!p) { + return NULL; + } + + newline = strchr(p, '\n'); + + if(!newline) { + return buf; + } + + /* kill newline and carriage return if necessary */ + *newline = '\0'; + + if(newline > p && newline[-1] == '\r') { + newline[-1] = '\0'; + } + + return buf; +} + +config_t *parse_config_line(char *line, const char *fname, int lineno) { + config_t *cfg; + int len; + char *variable, *value, *eol; + variable = value = line; + + eol = line + strlen(line); + + while(strchr("\t ", *--eol)) { + *eol = '\0'; + } + + len = strcspn(value, "\t ="); + value += len; + value += strspn(value, "\t "); + + if(*value == '=') { + value++; + value += strspn(value, "\t "); + } + + variable[len] = '\0'; + + if(!*value) { + const char err[] = "No value for variable"; + logger(NULL, MESHLINK_ERROR, "%s `%s' on line %d while reading config file %s", + err, variable, lineno, fname); + return NULL; + } + + cfg = new_config(); + cfg->variable = xstrdup(variable); + cfg->value = xstrdup(value); + cfg->line = lineno; + + return cfg; } /* 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 = -1; - FILE *fp; - char line[MAXBUFSIZE]; /* There really should not be any line longer than this... */ - char *p, *q; - int i, 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; - } - - 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; - } - - 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; - } - - cfg->which = hazahaza[i].which; - if(!config) - config = cfg; - } - - fclose (fp); -cp - return err; +bool read_config_file(splay_tree_t *config_tree, const char *fname) { + FILE *fp; + char buffer[MAX_STRING_SIZE]; + char *line; + int lineno = 0; + bool ignore = false; + config_t *cfg; + bool result = false; + + fp = fopen(fname, "r"); + + if(!fp) { + logger(NULL, MESHLINK_ERROR, "Cannot open config file %s: %s", fname, strerror(errno)); + return false; + } + + for(;;) { + line = readline(fp, buffer, sizeof(buffer)); + + if(!line) { + if(feof(fp)) { + result = true; + } + + break; + } + + lineno++; + + if(!*line || *line == '#') { + continue; + } + + if(ignore) { + if(!strncmp(line, "-----END", 8)) { + ignore = false; + } + + continue; + } + + if(!strncmp(line, "-----BEGIN", 10)) { + ignore = true; + continue; + } + + cfg = parse_config_line(line, fname, lineno); + + if(!cfg) { + break; + } + + config_add(config_tree, cfg); + } + + fclose(fp); + + return result; } -int read_server_config() -{ - char *fname; - int x; -cp - asprintf(&fname, "%s/tinc.conf", confbase); - x = read_config_file(&config, fname); - if(x != 0) - { - fprintf(stderr, _("Failed to read `%s': %m\n"), - fname); - } - free(fname); -cp - return x; +bool write_config_file(const struct splay_tree_t *config_tree, const char *fname) { + FILE *fp; + + fp = fopen(fname, "w+"); + + if(!fp) { + logger(NULL, MESHLINK_ERROR, "Cannot open config file %s: %s", fname, strerror(errno)); + return false; + } + + for splay_each(config_t, cnf, config_tree) { + if(fwrite(cnf->variable, sizeof(char), strlen(cnf->variable), fp) < strlen(cnf->variable)) { + goto error; + } + + if(fwrite(" = ", sizeof(char), 3, fp) < 3) { + goto error; + } + + if(fwrite(cnf->value, sizeof(char), strlen(cnf->value), fp) < strlen(cnf->value)) { + goto error; + } + + if(fwrite("\n", sizeof(char), 1, fp) < 1) { + goto error; + } + } + + fclose(fp); + return true; + +error: + logger(NULL, MESHLINK_ERROR, "Cannot write to config file %s: %s", fname, strerror(errno)); + fclose(fp); + return false; } -/* - Look up the value of the config option type -*/ -const config_t *get_config_val(config_t *p, which_t type) -{ -cp - for(; p != NULL; p = p->next) - if(p->which == type) - break; -cp - return p; +bool read_server_config(meshlink_handle_t *mesh) { + char filename[PATH_MAX]; + bool x; + + snprintf(filename, PATH_MAX, "%s" SLASH "meshlink.conf", mesh->confbase); + errno = 0; + x = read_config_file(mesh->config, filename); + + if(!x && errno) { + logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", filename, strerror(errno)); + } + + return x; } -/* - 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 != NULL; p = p->next) - if(p->which == type) - if(--index < 0) - break; -cp - return p; +bool read_host_config(meshlink_handle_t *mesh, splay_tree_t *config_tree, const char *name) { + char filename[PATH_MAX]; + bool x; + + snprintf(filename, PATH_MAX, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name); + x = read_config_file(config_tree, filename); + + return x; } -/* - 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 +bool write_host_config(struct meshlink_handle *mesh, const struct splay_tree_t *config_tree, const char *name) { + char filename[PATH_MAX]; + + snprintf(filename, PATH_MAX, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name); + return write_config_file(config_tree, filename); +} + +bool modify_config_file(struct meshlink_handle *mesh, const char *name, const char *key, const char *value, int trim) { + assert(mesh && name && key); + + char filename[PATH_MAX]; + char tmpname[PATH_MAX]; + bool error = false; + + if(snprintf(filename, sizeof(filename), "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name) >= PATH_MAX) { + logger(mesh, MESHLINK_ERROR, "Filename too long: %s" SLASH "hosts" SLASH "%s", mesh->confbase, name); + return false; + } + + if(snprintf(tmpname, sizeof(tmpname), "%s.tmp", filename) >= PATH_MAX) { + logger(mesh, MESHLINK_ERROR, "Filename too long: %s.tmp", filename); + return false; + } + + FILE *fr = fopen(filename, "r"); + + if(!fr) { + logger(mesh, MESHLINK_ERROR, "Cannot open config file %s: %s", filename, strerror(errno)); + return false; + } + + FILE *fw = fopen(tmpname, "w"); + + if(!fw) { + logger(mesh, MESHLINK_ERROR, "Cannot open temporary file %s: %s", tmpname, strerror(errno)); + fclose(fr); + return false; + } + + char buf[4096]; + char *sep; + int found = 0; + + if(value) { + fprintf(fw, "%s = %s\n", key, value); + found++; + } + + while(readline(fr, buf, sizeof(buf))) { + if(!*buf || *buf == '#') { + goto copy; + } + + sep = strchr(buf, ' '); + + if(!sep) { + goto copy; + } + + *sep = 0; + + if(strcmp(buf, key)) { + *sep = ' '; + goto copy; + } + + // We found the key and the value. We already added it at the top, so ignore this one. + if(value && sep[1] == '=' && sep[2] == ' ' && !strcmp(sep + 3, value)) { + continue; + } + + // We found the key but with a different value, delete it if wanted. + found++; + + if((!value || trim) && found > trim) { + continue; + } + + *sep = ' '; + +copy: + fprintf(fw, "%s\n", buf); + } + + if(ferror(fr)) { + error = true; + } + + fclose(fr); + + if(ferror(fw)) { + error = true; + } + + if(fclose(fw)) { + error = true; + } + + // If any error occured during reading or writing, exit. + if(error) { + unlink(tmpname); + return false; + } + + // Try to atomically replace the old config file with the new one. +#ifdef HAVE_MINGW + char bakname[PATH_MAX]; + snprintf(bakname, sizeof(bakname), "%s.bak", filename); + + if(rename(filename, bakname) || rename(tmpname, filename)) { + rename(bakname, filename); +#else + + if(rename(tmpname, filename)) { +#endif + return false; + } else { +#ifdef HAVE_MINGW + unlink(bakname); +#endif + return true; + } +} + +bool append_config_file(meshlink_handle_t *mesh, const char *name, const char *key, const char *value) { + return modify_config_file(mesh, name, key, value, 0); }