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