git.meshlink.io Git - meshlink/blob - src/conf.c

   1 /*
   2     conf.c -- configuration code
   3     Copyright (C) 2014 Guus Sliepen <guus@meshlink.io>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21 #include <assert.h>
  22
  23 #include "splay_tree.h"
  24 #include "connection.h"
  25 #include "conf.h"
  26 #include "list.h"
  27 #include "logger.h"
  28 #include "meshlink_internal.h"
  29 #include "netutl.h"             /* for str2address */
  30 #include "protocol.h"
  31 #include "utils.h"              /* for cp */
  32 #include "xalloc.h"
  33
  34 static int config_compare(const config_t *a, const config_t *b) {
  35         int result;
  36
  37         result = strcasecmp(a->variable, b->variable);
  38
  39         if(result)
  40                 return result;
  41
  42         result = a->line - b->line;
  43
  44         if(result)
  45                 return result;
  46         else
  47                 return a->file ? strcmp(a->file, b->file) : 0;
  48 }
  49
  50 void init_configuration(splay_tree_t **config_tree) {
  51         *config_tree = splay_alloc_tree((splay_compare_t) config_compare, (splay_action_t) free_config);
  52 }
  53
  54 void exit_configuration(splay_tree_t **config_tree) {
  55         if(*config_tree)
  56                 splay_delete_tree(*config_tree);
  57         *config_tree = NULL;
  58 }
  59
  60 config_t *new_config(void) {
  61         return xzalloc(sizeof(config_t));
  62 }
  63
  64 void free_config(config_t *cfg) {
  65         if(cfg->variable)
  66                 free(cfg->variable);
  67
  68         if(cfg->value)
  69                 free(cfg->value);
  70
  71         if(cfg->file)
  72                 free(cfg->file);
  73
  74         free(cfg);
  75 }
  76
  77 void config_add(splay_tree_t *config_tree, config_t *cfg) {
  78         splay_insert(config_tree, cfg);
  79 }
  80
  81 config_t *lookup_config(splay_tree_t *config_tree, char *variable) {
  82         config_t cfg, *found;
  83
  84         cfg.variable = variable;
  85         cfg.file = NULL;
  86         cfg.line = 0;
  87
  88         found = splay_search_closest_greater(config_tree, &cfg);
  89
  90         if(!found)
  91                 return NULL;
  92
  93         if(strcasecmp(found->variable, variable))
  94                 return NULL;
  95
  96         return found;
  97 }
  98
  99 config_t *lookup_config_next(splay_tree_t *config_tree, const config_t *cfg) {
 100         splay_node_t *node;
 101         config_t *found;
 102
 103         node = splay_search_node(config_tree, cfg);
 104
 105         if(node) {
 106                 if(node->next) {
 107                         found = node->next->data;
 108
 109                         if(!strcasecmp(found->variable, cfg->variable))
 110                                 return found;
 111                 }
 112         }
 113
 114         return NULL;
 115 }
 116
 117 bool get_config_bool(const config_t *cfg, bool *result) {
 118         if(!cfg)
 119                 return false;
 120
 121         if(!strcasecmp(cfg->value, "yes")) {
 122                 *result = true;
 123                 return true;
 124         } else if(!strcasecmp(cfg->value, "no")) {
 125                 *result = false;
 126                 return true;
 127         }
 128
 129         logger(NULL, MESHLINK_ERROR, "\"yes\" or \"no\" expected for configuration variable %s in %s line %d",
 130                cfg->variable, cfg->file, cfg->line);
 131
 132         return false;
 133 }
 134
 135 bool get_config_int(const config_t *cfg, int *result) {
 136         if(!cfg)
 137                 return false;
 138
 139         if(sscanf(cfg->value, "%d", result) == 1)
 140                 return true;
 141
 142         logger(NULL, MESHLINK_ERROR, "Integer expected for configuration variable %s in %s line %d",
 143                cfg->variable, cfg->file, cfg->line);
 144
 145         return false;
 146 }
 147
 148 bool set_config_int(config_t *cfg, int val) {
 149         if(!cfg)
 150                 return false;
 151
 152         char val_str[1024];
 153         snprintf(val_str, sizeof(val_str), "%d", val);
 154
 155         if(cfg->value)
 156                 free(cfg->value);
 157
 158         cfg->value = xstrdup(val_str);
 159
 160         return true;
 161 }
 162
 163 bool get_config_string(const config_t *cfg, char **result) {
 164         if(!cfg)
 165                 return false;
 166
 167         *result = xstrdup(cfg->value);
 168
 169         return true;
 170 }
 171
 172 bool set_config_string(config_t *cfg, const char* val) {
 173         if(!cfg)
 174                 return false;
 175
 176         if(cfg->value)
 177                 free(cfg->value);
 178
 179         cfg->value = xstrdup(val);
 180
 181         return true;
 182 }
 183
 184 bool get_config_address(const config_t *cfg, struct addrinfo **result) {
 185         struct addrinfo *ai;
 186
 187         if(!cfg)
 188                 return false;
 189
 190         ai = str2addrinfo(cfg->value, NULL, 0);
 191
 192         if(ai) {
 193                 *result = ai;
 194                 return true;
 195         }
 196
 197         logger(NULL, MESHLINK_ERROR, "Hostname or IP address expected for configuration variable %s in %s line %d",
 198                cfg->variable, cfg->file, cfg->line);
 199
 200         return false;
 201 }
 202
 203 /*
 204   Read exactly one line and strip the trailing newline if any.
 205 */
 206 static char *readline(FILE * fp, char *buf, size_t buflen) {
 207         char *newline = NULL;
 208         char *p;
 209
 210         if(feof(fp))
 211                 return NULL;
 212
 213         p = fgets(buf, buflen, fp);
 214
 215         if(!p)
 216                 return NULL;
 217
 218         newline = strchr(p, '\n');
 219
 220         if(!newline)
 221                 return buf;
 222
 223         /* kill newline and carriage return if necessary */
 224         *newline = '\0';
 225         if(newline > p && newline[-1] == '\r')
 226                 newline[-1] = '\0';
 227
 228         return buf;
 229 }
 230
 231 config_t *parse_config_line(char *line, const char *fname, int lineno) {
 232         config_t *cfg;
 233         int len;
 234         char *variable, *value, *eol;
 235         variable = value = line;
 236
 237         eol = line + strlen(line);
 238         while(strchr("\t ", *--eol))
 239                 *eol = '\0';
 240
 241         len = strcspn(value, "\t =");
 242         value += len;
 243         value += strspn(value, "\t ");
 244         if(*value == '=') {
 245                 value++;
 246                 value += strspn(value, "\t ");
 247         }
 248         variable[len] = '\0';
 249
 250         if(!*value) {
 251                 const char err[] = "No value for variable";
 252                 logger(NULL, MESHLINK_ERROR, "%s `%s' on line %d while reading config file %s",
 253                        err, variable, lineno, fname);
 254                 return NULL;
 255         }
 256
 257         cfg = new_config();
 258         cfg->variable = xstrdup(variable);
 259         cfg->value = xstrdup(value);
 260         cfg->file = xstrdup(fname);
 261         cfg->line = lineno;
 262
 263         return cfg;
 264 }
 265
 266 /*
 267   Parse a configuration file and put the results in the configuration tree
 268   starting at *base.
 269 */
 270 bool read_config_file(splay_tree_t *config_tree, const char *fname) {
 271         FILE *fp;
 272         char buffer[MAX_STRING_SIZE];
 273         char *line;
 274         int lineno = 0;
 275         bool ignore = false;
 276         config_t *cfg;
 277         bool result = false;
 278
 279         fp = fopen(fname, "r");
 280
 281         if(!fp) {
 282                 logger(NULL, MESHLINK_ERROR, "Cannot open config file %s: %s", fname, strerror(errno));
 283                 return false;
 284         }
 285
 286         for(;;) {
 287                 line = readline(fp, buffer, sizeof(buffer));
 288
 289                 if(!line) {
 290                         if(feof(fp))
 291                                 result = true;
 292                         break;
 293                 }
 294
 295                 lineno++;
 296
 297                 if(!*line || *line == '#')
 298                         continue;
 299
 300                 if(ignore) {
 301                         if(!strncmp(line, "-----END", 8))
 302                                 ignore = false;
 303                         continue;
 304                 }
 305
 306                 if(!strncmp(line, "-----BEGIN", 10)) {
 307                         ignore = true;
 308                         continue;
 309                 }
 310
 311                 cfg = parse_config_line(line, fname, lineno);
 312                 if(!cfg)
 313                         break;
 314                 config_add(config_tree, cfg);
 315         }
 316
 317         fclose(fp);
 318
 319         return result;
 320 }
 321
 322 bool write_config_file(const struct splay_tree_t *config_tree, const char *fname) {
 323         FILE *fp;
 324
 325         fp = fopen(fname, "w+");
 326
 327         if(!fp) {
 328                 logger(NULL, MESHLINK_ERROR, "Cannot open config file %s: %s", fname, strerror(errno));
 329                 return false;
 330         }
 331
 332         for splay_each(config_t, cnf, config_tree) {
 333                 if(fwrite(cnf->variable, sizeof(char), strlen(cnf->variable), fp) < strlen(cnf->variable))
 334                         goto error;
 335
 336                 if(fwrite(" = ", sizeof(char), 3, fp) < 3)
 337                         goto error;
 338
 339                 if(fwrite(cnf->value, sizeof(char), strlen(cnf->value), fp) < strlen(cnf->value))
 340                         goto error;
 341
 342                 if(fwrite("\n", sizeof(char), 1, fp) < 1)
 343                         goto error;
 344         }
 345
 346         fclose(fp);
 347         return true;
 348
 349 error:
 350         logger(NULL, MESHLINK_ERROR, "Cannot write to config file %s: %s", fname, strerror(errno));
 351         fclose(fp);
 352         return false;
 353 }
 354
 355 bool read_server_config(meshlink_handle_t *mesh) {
 356         char filename[PATH_MAX];
 357         bool x;
 358
 359         snprintf(filename, PATH_MAX,"%s" SLASH "meshlink.conf", mesh->confbase);
 360         errno = 0;
 361         x = read_config_file(mesh->config, filename);
 362
 363         if(!x && errno)
 364                 logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", filename, strerror(errno));
 365
 366         return x;
 367 }
 368
 369 bool read_host_config(meshlink_handle_t *mesh, splay_tree_t *config_tree, const char *name) {
 370         char filename[PATH_MAX];
 371         bool x;
 372
 373         snprintf(filename,PATH_MAX, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name);
 374         x = read_config_file(config_tree, filename);
 375
 376         return x;
 377 }
 378
 379 bool write_host_config(struct meshlink_handle *mesh, const struct splay_tree_t *config_tree, const char *name) {
 380         char filename[PATH_MAX];
 381
 382         snprintf(filename,PATH_MAX, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name);
 383         return write_config_file(config_tree, filename);
 384 }
 385
 386 bool modify_config_file(struct meshlink_handle *mesh, const char *name, const char *key, const char *value, bool replace) {
 387         assert(mesh && name && key && (replace || value));
 388
 389         char filename[PATH_MAX];
 390         char tmpname[PATH_MAX];
 391         bool error = false;
 392
 393         snprintf(filename, sizeof(filename), "%s" SLASH "hosts" SLASH "%s", mesh->confbase, name);
 394         snprintf(tmpname, sizeof(tmpname), "%s.tmp", filename);
 395
 396         FILE *fr = fopen(filename, "r");
 397
 398         if(!fr) {
 399                 logger(mesh, MESHLINK_ERROR, "Cannot open config file %s: %s", filename, strerror(errno));
 400                 return false;
 401         }
 402
 403         FILE *fw = fopen(tmpname, "w");
 404
 405         if(!fw) {
 406                 logger(mesh, MESHLINK_ERROR, "Cannot open temporary file %s: %s", tmpname, strerror(errno));
 407                 fclose(fr);
 408                 return false;
 409         }
 410
 411         char buf[4096];
 412         char *sep;
 413         bool found = false;
 414
 415         while(readline(fr, buf, sizeof(buf))) {
 416                 if(!*buf || *buf == '#')
 417                         goto copy;
 418
 419                 sep = strchr(buf, ' ');
 420                 if(!sep)
 421                         goto copy;
 422
 423                 *sep = 0;
 424                 if(strcmp(buf, key)) {
 425                         *sep = ' ';
 426                         goto copy;
 427                 }
 428
 429                 if(!value) {
 430                         found = true;
 431                         continue;
 432                 }
 433
 434                 // We found the key and the value. Keep one copy around.
 435                 if(sep[1] == '=' && sep[2] == ' ' && !strcmp(sep + 3, value)) {
 436                         if(found)
 437                                 continue;
 438                         found = true;
 439                 }
 440
 441                 // We found the key but with a different value, delete it if wanted.
 442                 if(!found && replace)
 443                         continue;
 444
 445                 *sep = ' ';
 446
 447 copy:
 448                 fprintf(fw, "%s\n", buf);
 449         }
 450
 451         if(ferror(fr))
 452                 error = true;
 453
 454         fclose(fr);
 455
 456         // Add new key/value pair if necessary
 457         if(!found && value)
 458                 fprintf(fw, "%s = %s\n", key, value);
 459
 460         if(ferror(fw))
 461                 error = true;
 462
 463         if(fclose(fw))
 464                 error = true;
 465
 466         // If any error occured during reading or writing, exit.
 467         if(error) {
 468                 unlink(tmpname);
 469                 return false;
 470         }
 471
 472         // Try to atomically replace the old config file with the new one.
 473 #ifdef HAVE_MINGW
 474         char bakname[PATH_MAX];
 475         snprintf(bakname, sizeof(bakname), "%s.bak", filename);
 476         if(rename(filename, bakname) || rename(tmpname, filename)) {
 477                 rename(bakname, filename);
 478 #else
 479         if(rename(tmpname, filename)) {
 480 #endif
 481                 return false;
 482         } else {
 483 #ifdef HAVE_MINGW
 484                 unlink(bakname);
 485 #endif
 486                 return true;
 487         }
 488 }
 489
 490 bool append_config_file(meshlink_handle_t *mesh, const char *name, const char *key, const char *value) {
 491         return modify_config_file(mesh, name, key, value, false);
 492 }