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

   1 /*
   2     econf.c -- configuration code
   3     Copyright (C) 2018 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 #include <sys/types.h>
  23 #include <utime.h>
  24
  25 #include "conf.h"
  26 #include "crypto.h"
  27 #include "logger.h"
  28 #include "meshlink_internal.h"
  29 #include "xalloc.h"
  30 #include "packmsg.h"
  31
  32 /// Generate a path to the main configuration file.
  33 static void make_main_path(meshlink_handle_t *mesh, const char *conf_subdir, char *path, size_t len) {
  34         assert(conf_subdir);
  35         assert(path);
  36         assert(len);
  37
  38         snprintf(path, len, "%s" SLASH "%s" SLASH "meshlink.conf", mesh->confbase, conf_subdir);
  39 }
  40
  41 /// Generate a path to a host configuration file.
  42 static void make_host_path(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, char *path, size_t len) {
  43         assert(conf_subdir);
  44         assert(name);
  45         assert(path);
  46         assert(len);
  47
  48         snprintf(path, len, "%s" SLASH "%s" SLASH "hosts" SLASH "%s", mesh->confbase, conf_subdir, name);
  49 }
  50
  51 /// Generate a path to an unused invitation file.
  52 static void make_invitation_path(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, char *path, size_t len) {
  53         assert(conf_subdir);
  54         assert(name);
  55         assert(path);
  56         assert(len);
  57
  58         snprintf(path, len, "%s" SLASH "%s" SLASH "invitations" SLASH "%s", mesh->confbase, conf_subdir, name);
  59 }
  60
  61 /// Generate a path to a used invitation file.
  62 static void make_used_invitation_path(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, char *path, size_t len) {
  63         assert(conf_subdir);
  64         assert(name);
  65         assert(path);
  66         assert(len);
  67
  68         snprintf(path, len, "%s" SLASH "%s" SLASH "invitations" SLASH "%s.used", mesh->confbase, conf_subdir, name);
  69 }
  70
  71 /// Remove a directory recursively
  72 static bool deltree(const char *dirname) {
  73         assert(dirname);
  74
  75         DIR *d = opendir(dirname);
  76
  77         if(d) {
  78                 struct dirent *ent;
  79
  80                 while((ent = readdir(d))) {
  81                         if(ent->d_name[0] == '.') {
  82                                 if(!ent->d_name[1] || (ent->d_name[1] == '.' && !ent->d_name[2])) {
  83                                         continue;
  84                                 }
  85                         }
  86
  87                         char filename[PATH_MAX];
  88                         snprintf(filename, sizeof(filename), "%s" SLASH "%s", dirname, ent->d_name);
  89
  90                         if(unlink(filename)) {
  91                                 if(!deltree(filename)) {
  92                                         return false;
  93                                 }
  94                         }
  95                 }
  96
  97                 closedir(d);
  98         } else {
  99                 return errno == ENOENT;
 100         }
 101
 102         return rmdir(dirname) == 0;
 103 }
 104
 105 bool sync_path(const char *pathname) {
 106         assert(pathname);
 107
 108         int fd = open(pathname, O_RDONLY);
 109
 110         if(fd < 0) {
 111                 logger(NULL, MESHLINK_ERROR, "Failed to open %s: %s\n", pathname, strerror(errno));
 112                 meshlink_errno = MESHLINK_ESTORAGE;
 113                 return false;
 114         }
 115
 116         if(fsync(fd)) {
 117                 logger(NULL, MESHLINK_ERROR, "Failed to sync %s: %s\n", pathname, strerror(errno));
 118                 close(fd);
 119                 meshlink_errno = MESHLINK_ESTORAGE;
 120                 return false;
 121         }
 122
 123         if(close(fd)) {
 124                 logger(NULL, MESHLINK_ERROR, "Failed to close %s: %s\n", pathname, strerror(errno));
 125                 close(fd);
 126                 meshlink_errno = MESHLINK_ESTORAGE;
 127                 return false;
 128         }
 129
 130         return true;
 131 }
 132
 133 /// Try decrypting the main configuration file from the given sub-directory.
 134 static bool main_config_decrypt(meshlink_handle_t *mesh, const char *conf_subdir) {
 135         assert(mesh->config_key);
 136         assert(mesh->confbase);
 137         assert(conf_subdir);
 138
 139         config_t config;
 140
 141         if(!main_config_read(mesh, conf_subdir, &config, mesh->config_key)) {
 142                 logger(mesh, MESHLINK_ERROR, "Could not read main configuration file");
 143                 return false;
 144         }
 145
 146         packmsg_input_t in = {config.buf, config.len};
 147
 148         uint32_t version = packmsg_get_uint32(&in);
 149         config_free(&config);
 150
 151         return version == MESHLINK_CONFIG_VERSION;
 152 }
 153
 154 /// Create a fresh configuration directory
 155 bool config_init(meshlink_handle_t *mesh, const char *conf_subdir) {
 156         assert(conf_subdir);
 157
 158         if(!mesh->confbase) {
 159                 return true;
 160         }
 161
 162         char path[PATH_MAX];
 163
 164         // Create "current" sub-directory in the confbase
 165         snprintf(path, sizeof(path), "%s" SLASH "%s", mesh->confbase, conf_subdir);
 166
 167         if(!deltree(path)) {
 168                 logger(mesh, MESHLINK_DEBUG, "Could not delete directory %s: %s\n", path, strerror(errno));
 169                 return false;
 170         }
 171
 172         if(mkdir(path, 0700)) {
 173                 logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno));
 174                 return false;
 175         }
 176
 177         make_host_path(mesh, conf_subdir, "", path, sizeof(path));
 178
 179         if(mkdir(path, 0700)) {
 180                 logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno));
 181                 return false;
 182         }
 183
 184         make_invitation_path(mesh, conf_subdir, "", path, sizeof(path));
 185
 186         if(mkdir(path, 0700)) {
 187                 logger(mesh, MESHLINK_DEBUG, "Could not create directory %s: %s\n", path, strerror(errno));
 188                 return false;
 189         }
 190
 191         return true;
 192 }
 193
 194 /// Wipe an existing configuration directory
 195 bool config_destroy(const char *confbase, const char *conf_subdir) {
 196         assert(conf_subdir);
 197
 198         if(!confbase) {
 199                 return true;
 200         }
 201
 202         struct stat st;
 203
 204         char path[PATH_MAX];
 205
 206         // Check the presence of configuration base sub directory.
 207         snprintf(path, sizeof(path), "%s" SLASH "%s", confbase, conf_subdir);
 208
 209         if(stat(path, &st)) {
 210                 if(errno == ENOENT) {
 211                         return true;
 212                 } else {
 213                         logger(NULL, MESHLINK_ERROR, "Cannot stat %s: %s\n", path, strerror(errno));
 214                         meshlink_errno = MESHLINK_ESTORAGE;
 215                         return false;
 216                 }
 217         }
 218
 219         // Remove meshlink.conf
 220         snprintf(path, sizeof(path), "%s" SLASH "%s" SLASH "meshlink.conf", confbase, conf_subdir);
 221
 222         if(unlink(path)) {
 223                 if(errno != ENOENT) {
 224                         logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", path, strerror(errno));
 225                         meshlink_errno = MESHLINK_ESTORAGE;
 226                         return false;
 227                 }
 228         }
 229
 230         snprintf(path, sizeof(path), "%s" SLASH "%s", confbase, conf_subdir);
 231
 232         if(!deltree(path)) {
 233                 logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", path, strerror(errno));
 234                 meshlink_errno = MESHLINK_ESTORAGE;
 235                 return false;
 236         }
 237
 238         return sync_path(confbase);
 239 }
 240
 241 static bool copytree(const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key) {
 242         assert(src_dir_name);
 243         assert(dst_dir_name);
 244
 245         char src_filename[PATH_MAX];
 246         char dst_filename[PATH_MAX];
 247         struct dirent *ent;
 248
 249         DIR *src_dir = opendir(src_dir_name);
 250
 251         if(!src_dir) {
 252                 logger(NULL, MESHLINK_ERROR, "Could not open directory file %s\n", src_dir_name);
 253                 meshlink_errno = MESHLINK_ESTORAGE;
 254                 return false;
 255         }
 256
 257         // Delete if already exists and create a new destination directory
 258         if(!deltree(dst_dir_name)) {
 259                 logger(NULL, MESHLINK_ERROR, "Cannot delete %s: %s\n", dst_dir_name, strerror(errno));
 260                 meshlink_errno = MESHLINK_ESTORAGE;
 261                 return false;
 262         }
 263
 264         if(mkdir(dst_dir_name, 0700)) {
 265                 logger(NULL, MESHLINK_ERROR, "Could not create directory %s\n", dst_filename);
 266                 meshlink_errno = MESHLINK_ESTORAGE;
 267                 return false;
 268         }
 269
 270         while((ent = readdir(src_dir))) {
 271                 if(ent->d_name[0] == '.') {
 272                         continue;
 273                 }
 274
 275                 snprintf(dst_filename, sizeof(dst_filename), "%s" SLASH "%s", dst_dir_name, ent->d_name);
 276                 snprintf(src_filename, sizeof(src_filename), "%s" SLASH "%s", src_dir_name, ent->d_name);
 277
 278                 if(ent->d_type == DT_DIR) {
 279                         if(!copytree(src_filename, src_key, dst_filename, dst_key)) {
 280                                 logger(NULL, MESHLINK_ERROR, "Copying %s to %s failed\n", src_filename, dst_filename);
 281                                 meshlink_errno = MESHLINK_ESTORAGE;
 282                                 return false;
 283                         }
 284
 285                         if(!sync_path(dst_filename)) {
 286                                 return false;
 287                         }
 288                 } else if(ent->d_type == DT_REG) {
 289                         struct stat st;
 290                         config_t config;
 291
 292                         if(stat(src_filename, &st)) {
 293                                 logger(NULL, MESHLINK_ERROR, "Could not stat file `%s': %s\n", src_filename, strerror(errno));
 294                                 meshlink_errno = MESHLINK_ESTORAGE;
 295                                 return false;
 296                         }
 297
 298                         FILE *f = fopen(src_filename, "r");
 299
 300                         if(!f) {
 301                                 logger(NULL, MESHLINK_ERROR, "Failed to open `%s': %s\n", src_filename, strerror(errno));
 302                                 meshlink_errno = MESHLINK_ESTORAGE;
 303                                 return false;
 304                         }
 305
 306                         if(!config_read_file(NULL, f, &config, src_key)) {
 307                                 logger(NULL, MESHLINK_ERROR, "Failed to read `%s': %s\n", src_filename, strerror(errno));
 308                                 fclose(f);
 309                                 meshlink_errno = MESHLINK_ESTORAGE;
 310                                 return false;
 311                         }
 312
 313                         if(fclose(f)) {
 314                                 logger(NULL, MESHLINK_ERROR, "Failed to close `%s': %s\n", src_filename, strerror(errno));
 315                                 config_free(&config);
 316                                 meshlink_errno = MESHLINK_ESTORAGE;
 317                                 return false;
 318                         }
 319
 320                         f = fopen(dst_filename, "w");
 321
 322                         if(!f) {
 323                                 logger(NULL, MESHLINK_ERROR, "Failed to open `%s': %s", dst_filename, strerror(errno));
 324                                 config_free(&config);
 325                                 meshlink_errno = MESHLINK_ESTORAGE;
 326                                 return false;
 327                         }
 328
 329                         if(!config_write_file(NULL, f, &config, dst_key)) {
 330                                 logger(NULL, MESHLINK_ERROR, "Failed to write `%s': %s", dst_filename, strerror(errno));
 331                                 config_free(&config);
 332                                 fclose(f);
 333                                 meshlink_errno = MESHLINK_ESTORAGE;
 334                                 return false;
 335                         }
 336
 337                         if(fclose(f)) {
 338                                 logger(NULL, MESHLINK_ERROR, "Failed to close `%s': %s", dst_filename, strerror(errno));
 339                                 config_free(&config);
 340                                 meshlink_errno = MESHLINK_ESTORAGE;
 341                                 return false;
 342                         }
 343
 344                         config_free(&config);
 345
 346                         struct utimbuf times;
 347                         times.modtime = st.st_mtime;
 348                         times.actime = st.st_atime;
 349
 350                         if(utime(dst_filename, &times)) {
 351                                 logger(NULL, MESHLINK_ERROR, "Failed to utime `%s': %s", dst_filename, strerror(errno));
 352                                 meshlink_errno = MESHLINK_ESTORAGE;
 353                                 return false;
 354                         }
 355                 }
 356         }
 357
 358         closedir(src_dir);
 359         return true;
 360 }
 361
 362 bool config_copy(meshlink_handle_t *mesh, const char *src_dir_name, const void *src_key, const char *dst_dir_name, const void *dst_key) {
 363         assert(src_dir_name);
 364         assert(dst_dir_name);
 365
 366         char src_filename[PATH_MAX];
 367         char dst_filename[PATH_MAX];
 368
 369         snprintf(dst_filename, sizeof(dst_filename), "%s" SLASH "%s", mesh->confbase, dst_dir_name);
 370         snprintf(src_filename, sizeof(src_filename), "%s" SLASH "%s", mesh->confbase, src_dir_name);
 371
 372         return copytree(src_filename, src_key, dst_filename, dst_key);
 373 }
 374
 375 /// Check the presence of the main configuration file.
 376 bool main_config_exists(meshlink_handle_t *mesh, const char *conf_subdir) {
 377         assert(conf_subdir);
 378
 379         if(!mesh->confbase) {
 380                 return false;
 381         }
 382
 383         char path[PATH_MAX];
 384         make_main_path(mesh, conf_subdir, path, sizeof(path));
 385         return access(path, F_OK) == 0;
 386 }
 387
 388 bool config_rename(meshlink_handle_t *mesh, const char *old_conf_subdir, const char *new_conf_subdir) {
 389         assert(old_conf_subdir);
 390         assert(new_conf_subdir);
 391
 392         if(!mesh->confbase) {
 393                 return false;
 394         }
 395
 396         char old_path[PATH_MAX];
 397         char new_path[PATH_MAX];
 398
 399         snprintf(old_path, sizeof(old_path), "%s" SLASH "%s", mesh->confbase, old_conf_subdir);
 400         snprintf(new_path, sizeof(new_path), "%s" SLASH "%s", mesh->confbase, new_conf_subdir);
 401
 402         return rename(old_path, new_path) == 0 && sync_path(mesh->confbase);
 403 }
 404
 405 bool config_sync(meshlink_handle_t *mesh, const char *conf_subdir) {
 406         assert(conf_subdir);
 407
 408         if(!mesh->confbase || mesh->storage_policy == MESHLINK_STORAGE_DISABLED) {
 409                 return true;
 410         }
 411
 412         char path[PATH_MAX];
 413         snprintf(path, sizeof(path), "%s" SLASH "%s" SLASH "hosts", mesh->confbase, conf_subdir);
 414
 415         if(!sync_path(path)) {
 416                 return false;
 417         }
 418
 419         snprintf(path, sizeof(path), "%s" SLASH "%s", mesh->confbase, conf_subdir);
 420
 421         if(!sync_path(path)) {
 422                 return false;
 423         }
 424
 425         return true;
 426 }
 427
 428 bool meshlink_confbase_exists(meshlink_handle_t *mesh) {
 429         if(!mesh->confbase) {
 430                 return false;
 431         }
 432
 433         bool confbase_exists = false;
 434         bool confbase_decryptable = false;
 435
 436         if(main_config_exists(mesh, "current")) {
 437                 confbase_exists = true;
 438
 439                 if(mesh->config_key && main_config_decrypt(mesh, "current")) {
 440                         confbase_decryptable = true;
 441                 }
 442         }
 443
 444         if(mesh->config_key && !confbase_decryptable && main_config_exists(mesh, "new")) {
 445                 confbase_exists = true;
 446
 447                 if(main_config_decrypt(mesh, "new")) {
 448                         if(!config_destroy(mesh->confbase, "current")) {
 449                                 return false;
 450                         }
 451
 452                         if(!config_rename(mesh, "new", "current")) {
 453                                 return false;
 454                         }
 455
 456                         confbase_decryptable = true;
 457                 }
 458         }
 459
 460         if(mesh->config_key && !confbase_decryptable && main_config_exists(mesh, "old")) {
 461                 confbase_exists = true;
 462
 463                 if(main_config_decrypt(mesh, "old")) {
 464                         if(!config_destroy(mesh->confbase, "current")) {
 465                                 return false;
 466                         }
 467
 468                         if(!config_rename(mesh, "old", "current")) {
 469                                 return false;
 470                         }
 471
 472                         confbase_decryptable = true;
 473                 }
 474         }
 475
 476         // Cleanup if current is existing with old and new
 477         if(confbase_exists && confbase_decryptable) {
 478                 if(!config_destroy(mesh->confbase, "old") || !config_destroy(mesh->confbase, "new")) {
 479                         return false;
 480                 }
 481         }
 482
 483         return confbase_exists;
 484 }
 485
 486 /// Lock the main configuration file. Creates confbase if necessary.
 487 bool main_config_lock(meshlink_handle_t *mesh, const char *lock_filename) {
 488         if(!mesh->confbase) {
 489                 return true;
 490         }
 491
 492         assert(lock_filename);
 493
 494         if(mkdir(mesh->confbase, 0700) && errno != EEXIST) {
 495                 logger(NULL, MESHLINK_ERROR, "Cannot create configuration directory %s: %s", mesh->confbase, strerror(errno));
 496                 meshlink_close(mesh);
 497                 meshlink_errno = MESHLINK_ESTORAGE;
 498                 return NULL;
 499         }
 500
 501         mesh->lockfile = fopen(lock_filename, "w+");
 502
 503         if(!mesh->lockfile) {
 504                 logger(NULL, MESHLINK_ERROR, "Cannot not open %s: %s\n", lock_filename, strerror(errno));
 505                 meshlink_errno = MESHLINK_ESTORAGE;
 506                 return false;
 507         }
 508
 509 #ifdef FD_CLOEXEC
 510         fcntl(fileno(mesh->lockfile), F_SETFD, FD_CLOEXEC);
 511 #endif
 512
 513 #ifdef HAVE_MINGW
 514         // TODO: use _locking()?
 515 #else
 516
 517         if(flock(fileno(mesh->lockfile), LOCK_EX | LOCK_NB) != 0) {
 518                 logger(NULL, MESHLINK_ERROR, "Cannot lock %s: %s\n", lock_filename, strerror(errno));
 519                 fclose(mesh->lockfile);
 520                 mesh->lockfile = NULL;
 521                 meshlink_errno = MESHLINK_EBUSY;
 522                 return false;
 523         }
 524
 525 #endif
 526
 527         return true;
 528 }
 529
 530 /// Unlock the main configuration file.
 531 void main_config_unlock(meshlink_handle_t *mesh) {
 532         if(mesh->lockfile) {
 533                 fclose(mesh->lockfile);
 534                 mesh->lockfile = NULL;
 535         }
 536 }
 537
 538 /// Read a configuration file from a FILE handle.
 539 bool config_read_file(meshlink_handle_t *mesh, FILE *f, config_t *config, const void *key) {
 540         assert(f);
 541
 542         long len;
 543
 544         if(fseek(f, 0, SEEK_END) || !(len = ftell(f)) || fseek(f, 0, SEEK_SET)) {
 545                 logger(mesh, MESHLINK_ERROR, "Cannot get config file size: %s\n", strerror(errno));
 546                 meshlink_errno = MESHLINK_ESTORAGE;
 547                 return false;
 548         }
 549
 550         uint8_t *buf = xmalloc(len);
 551
 552         if(fread(buf, len, 1, f) != 1) {
 553                 logger(mesh, MESHLINK_ERROR, "Cannot read config file: %s\n", strerror(errno));
 554                 meshlink_errno = MESHLINK_ESTORAGE;
 555                 return false;
 556         }
 557
 558         if(key) {
 559                 uint8_t *decrypted = xmalloc(len);
 560                 size_t decrypted_len = len;
 561                 chacha_poly1305_ctx_t *ctx = chacha_poly1305_init();
 562                 chacha_poly1305_set_key(ctx, key);
 563
 564                 if(len > 12 && chacha_poly1305_decrypt_iv96(ctx, buf, buf + 12, len - 12, decrypted, &decrypted_len)) {
 565                         chacha_poly1305_exit(ctx);
 566                         free(buf);
 567                         config->buf = decrypted;
 568                         config->len = decrypted_len;
 569                         return true;
 570                 } else {
 571                         logger(mesh, MESHLINK_ERROR, "Cannot decrypt config file\n");
 572                         meshlink_errno = MESHLINK_ESTORAGE;
 573                         chacha_poly1305_exit(ctx);
 574                         free(decrypted);
 575                         free(buf);
 576                         return false;
 577                 }
 578         }
 579
 580         config->buf = buf;
 581         config->len = len;
 582
 583         return true;
 584 }
 585
 586 /// Write a configuration file to a FILE handle.
 587 bool config_write_file(meshlink_handle_t *mesh, FILE *f, const config_t *config, const void *key) {
 588         assert(f);
 589
 590         if(key) {
 591                 uint8_t buf[config->len + 16];
 592                 size_t len = sizeof(buf);
 593                 uint8_t seqbuf[12];
 594                 randomize(&seqbuf, sizeof(seqbuf));
 595                 chacha_poly1305_ctx_t *ctx = chacha_poly1305_init();
 596                 chacha_poly1305_set_key(ctx, key);
 597                 bool success = false;
 598
 599                 if(chacha_poly1305_encrypt_iv96(ctx, seqbuf, config->buf, config->len, buf, &len)) {
 600                         success = fwrite(seqbuf, sizeof(seqbuf), 1, f) == 1 && fwrite(buf, len, 1, f) == 1;
 601
 602                         if(!success) {
 603                                 logger(mesh, MESHLINK_ERROR, "Cannot write config file: %s", strerror(errno));
 604                         }
 605
 606                         meshlink_errno = MESHLINK_ESTORAGE;
 607                 } else {
 608                         logger(mesh, MESHLINK_ERROR, "Cannot encrypt config file\n");
 609                         meshlink_errno = MESHLINK_ESTORAGE;
 610                 }
 611
 612                 chacha_poly1305_exit(ctx);
 613                 return success;
 614         }
 615
 616         if(fwrite(config->buf, config->len, 1, f) != 1) {
 617                 logger(mesh, MESHLINK_ERROR, "Cannot write config file: %s", strerror(errno));
 618                 meshlink_errno = MESHLINK_ESTORAGE;
 619                 return false;
 620         }
 621
 622         if(fflush(f)) {
 623                 logger(mesh, MESHLINK_ERROR, "Failed to flush file: %s", strerror(errno));
 624                 meshlink_errno = MESHLINK_ESTORAGE;
 625                 return false;
 626         }
 627
 628         if(fsync(fileno(f))) {
 629                 logger(mesh, MESHLINK_ERROR, "Failed to sync file: %s\n", strerror(errno));
 630                 meshlink_errno = MESHLINK_ESTORAGE;
 631                 return false;
 632         }
 633
 634         return true;
 635 }
 636
 637 /// Free resources of a loaded configuration file.
 638 void config_free(config_t *config) {
 639         assert(!config->len || config->buf);
 640
 641         free((uint8_t *)config->buf);
 642         config->buf = NULL;
 643         config->len = 0;
 644 }
 645
 646 /// Check the presence of a host configuration file.
 647 bool config_exists(meshlink_handle_t *mesh, const char *conf_subdir, const char *name) {
 648         assert(conf_subdir);
 649
 650         if(!mesh->confbase) {
 651                 return false;
 652         }
 653
 654         char path[PATH_MAX];
 655         make_host_path(mesh, conf_subdir, name, path, sizeof(path));
 656
 657         return access(path, F_OK) == 0;
 658 }
 659
 660 /// Read a host configuration file.
 661 bool config_read(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, config_t *config, void *key) {
 662         assert(conf_subdir);
 663
 664         if(!mesh->confbase) {
 665                 return false;
 666         }
 667
 668         char path[PATH_MAX];
 669         make_host_path(mesh, conf_subdir, name, path, sizeof(path));
 670
 671         FILE *f = fopen(path, "r");
 672
 673         if(!f) {
 674                 logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno));
 675                 return false;
 676         }
 677
 678         if(!config_read_file(mesh, f, config, key)) {
 679                 logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno));
 680                 fclose(f);
 681                 return false;
 682         }
 683
 684         fclose(f);
 685
 686         return true;
 687 }
 688
 689 bool config_scan_all(meshlink_handle_t *mesh, const char *conf_subdir, const char *conf_type, config_scan_action_t action, void *arg) {
 690         assert(conf_subdir);
 691         assert(conf_type);
 692
 693         if(!mesh->confbase) {
 694                 return true;
 695         }
 696
 697         DIR *dir;
 698         struct dirent *ent;
 699         char dname[PATH_MAX];
 700         snprintf(dname, sizeof(dname), "%s" SLASH "%s" SLASH "%s", mesh->confbase, conf_subdir, conf_type);
 701
 702         dir = opendir(dname);
 703
 704         if(!dir) {
 705                 logger(mesh, MESHLINK_ERROR, "Could not open %s: %s", dname, strerror(errno));
 706                 meshlink_errno = MESHLINK_ESTORAGE;
 707                 return false;
 708         }
 709
 710         while((ent = readdir(dir))) {
 711                 if(ent->d_name[0] == '.') {
 712                         continue;
 713                 }
 714
 715                 if(!action(mesh, ent->d_name, arg)) {
 716                         closedir(dir);
 717                         return false;
 718                 }
 719         }
 720
 721         closedir(dir);
 722         return true;
 723 }
 724
 725 /// Write a host configuration file.
 726 bool config_write(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, const config_t *config, void *key) {
 727         assert(conf_subdir);
 728         assert(name);
 729         assert(config);
 730
 731         if(!mesh->confbase) {
 732                 return true;
 733         }
 734
 735         char path[PATH_MAX];
 736         char tmp_path[PATH_MAX + 4];
 737         make_host_path(mesh, conf_subdir, name, path, sizeof(path));
 738         snprintf(tmp_path, sizeof(tmp_path), "%s.tmp", path);
 739
 740         FILE *f = fopen(tmp_path, "w");
 741
 742         if(!f) {
 743                 logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", tmp_path, strerror(errno));
 744                 meshlink_errno = MESHLINK_ESTORAGE;
 745                 return false;
 746         }
 747
 748         if(!config_write_file(mesh, f, config, key)) {
 749                 logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", tmp_path, strerror(errno));
 750                 fclose(f);
 751                 return false;
 752         }
 753
 754         if(fclose(f)) {
 755                 logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", tmp_path, strerror(errno));
 756                 meshlink_errno = MESHLINK_ESTORAGE;
 757                 return false;
 758         }
 759
 760         if(rename(tmp_path, path)) {
 761                 logger(mesh, MESHLINK_ERROR, "Failed to rename `%s' to `%s': %s", tmp_path, path, strerror(errno));
 762                 meshlink_errno = MESHLINK_ESTORAGE;
 763                 return false;
 764         }
 765
 766         return true;
 767 }
 768
 769 /// Delete a host configuration file.
 770 bool config_delete(meshlink_handle_t *mesh, const char *conf_subdir, const char *name) {
 771         assert(conf_subdir);
 772         assert(name);
 773
 774         if(!mesh->confbase) {
 775                 return true;
 776         }
 777
 778         char path[PATH_MAX];
 779         make_host_path(mesh, conf_subdir, name, path, sizeof(path));
 780
 781         if(unlink(path) && errno != ENOENT) {
 782                 logger(mesh, MESHLINK_ERROR, "Failed to unlink `%s': %s", path, strerror(errno));
 783                 meshlink_errno = MESHLINK_ESTORAGE;
 784                 return false;
 785         }
 786
 787         return true;
 788 }
 789
 790 /// Read the main configuration file.
 791 bool main_config_read(meshlink_handle_t *mesh, const char *conf_subdir, config_t *config, void *key) {
 792         assert(conf_subdir);
 793         assert(config);
 794
 795         if(!mesh->confbase) {
 796                 return false;
 797         }
 798
 799         char path[PATH_MAX];
 800         make_main_path(mesh, conf_subdir, path, sizeof(path));
 801
 802         FILE *f = fopen(path, "r");
 803
 804         if(!f) {
 805                 logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno));
 806                 return false;
 807         }
 808
 809         if(!config_read_file(mesh, f, config, key)) {
 810                 logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno));
 811                 fclose(f);
 812                 return false;
 813         }
 814
 815         fclose(f);
 816
 817         return true;
 818 }
 819
 820 /// Write the main configuration file.
 821 bool main_config_write(meshlink_handle_t *mesh, const char *conf_subdir, const config_t *config, void *key) {
 822         assert(conf_subdir);
 823         assert(config);
 824
 825         if(!mesh->confbase) {
 826                 return true;
 827         }
 828
 829         char path[PATH_MAX];
 830         char tmp_path[PATH_MAX + 4];
 831         make_main_path(mesh, conf_subdir, path, sizeof(path));
 832         snprintf(tmp_path, sizeof(tmp_path), "%s.tmp", path);
 833
 834         FILE *f = fopen(tmp_path, "w");
 835
 836         if(!f) {
 837                 logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", tmp_path, strerror(errno));
 838                 meshlink_errno = MESHLINK_ESTORAGE;
 839                 return false;
 840         }
 841
 842         if(!config_write_file(mesh, f, config, key)) {
 843                 logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", tmp_path, strerror(errno));
 844                 fclose(f);
 845                 return false;
 846         }
 847
 848         if(rename(tmp_path, path)) {
 849                 logger(mesh, MESHLINK_ERROR, "Failed to rename `%s' to `%s': %s", tmp_path, path, strerror(errno));
 850                 meshlink_errno = MESHLINK_ESTORAGE;
 851                 fclose(f);
 852                 return false;
 853         }
 854
 855         if(fclose(f)) {
 856                 logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", tmp_path, strerror(errno));
 857                 meshlink_errno = MESHLINK_ESTORAGE;
 858                 return false;
 859         }
 860
 861         return true;
 862 }
 863
 864 /// Read an invitation file from the confbase sub-directory, and immediately delete it.
 865 bool invitation_read(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, config_t *config, void *key) {
 866         assert(conf_subdir);
 867         assert(name);
 868         assert(config);
 869
 870         if(!mesh->confbase) {
 871                 return false;
 872         }
 873
 874         char path[PATH_MAX];
 875         char used_path[PATH_MAX];
 876         make_invitation_path(mesh, conf_subdir, name, path, sizeof(path));
 877         make_used_invitation_path(mesh, conf_subdir, name, used_path, sizeof(used_path));
 878
 879         // Atomically rename the invitation file
 880         if(rename(path, used_path)) {
 881                 if(errno == ENOENT) {
 882                         logger(mesh, MESHLINK_ERROR, "Peer tried to use non-existing invitation %s\n", name);
 883                 } else {
 884                         logger(mesh, MESHLINK_ERROR, "Error trying to rename invitation %s\n", name);
 885                 }
 886
 887                 return false;
 888         }
 889
 890         FILE *f = fopen(used_path, "r");
 891
 892         if(!f) {
 893                 logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno));
 894                 return false;
 895         }
 896
 897         // Check the timestamp
 898         struct stat st;
 899
 900         if(fstat(fileno(f), &st)) {
 901                 logger(mesh, MESHLINK_ERROR, "Could not stat invitation file %s\n", name);
 902                 fclose(f);
 903                 unlink(used_path);
 904                 return false;
 905         }
 906
 907         if(time(NULL) >= st.st_mtime + mesh->invitation_timeout) {
 908                 logger(mesh, MESHLINK_ERROR, "Peer tried to use an outdated invitation file %s\n", name);
 909                 fclose(f);
 910                 unlink(used_path);
 911                 return false;
 912         }
 913
 914         if(!config_read_file(mesh, f, config, key)) {
 915                 logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", path, strerror(errno));
 916                 fclose(f);
 917                 unlink(used_path);
 918                 return false;
 919         }
 920
 921         fclose(f);
 922
 923         if(unlink(used_path)) {
 924                 logger(mesh, MESHLINK_ERROR, "Failed to unlink `%s': %s", path, strerror(errno));
 925                 return false;
 926         }
 927
 928         snprintf(path, sizeof(path), "%s" SLASH "%s" SLASH "invitations", mesh->confbase, conf_subdir);
 929
 930         if(!sync_path(path)) {
 931                 logger(mesh, MESHLINK_ERROR, "Failed to sync `%s': %s", path, strerror(errno));
 932                 meshlink_errno = MESHLINK_ESTORAGE;
 933                 return false;
 934         }
 935
 936         return true;
 937 }
 938
 939 /// Write an invitation file.
 940 bool invitation_write(meshlink_handle_t *mesh, const char *conf_subdir, const char *name, const config_t *config, void *key) {
 941         assert(conf_subdir);
 942         assert(name);
 943         assert(config);
 944
 945         if(!mesh->confbase) {
 946                 return false;
 947         }
 948
 949         char path[PATH_MAX];
 950         make_invitation_path(mesh, conf_subdir, name, path, sizeof(path));
 951
 952         FILE *f = fopen(path, "w");
 953
 954         if(!f) {
 955                 logger(mesh, MESHLINK_ERROR, "Failed to open `%s': %s", path, strerror(errno));
 956                 meshlink_errno = MESHLINK_ESTORAGE;
 957                 return false;
 958         }
 959
 960         if(!config_write_file(mesh, f, config, key)) {
 961                 logger(mesh, MESHLINK_ERROR, "Failed to write `%s': %s", path, strerror(errno));
 962                 fclose(f);
 963                 return false;
 964         }
 965
 966         if(fclose(f)) {
 967                 logger(mesh, MESHLINK_ERROR, "Failed to close `%s': %s", path, strerror(errno));
 968                 meshlink_errno = MESHLINK_ESTORAGE;
 969                 return false;
 970         }
 971
 972         snprintf(path, sizeof(path), "%s" SLASH "%s" SLASH "invitations", mesh->confbase, conf_subdir);
 973
 974         if(!sync_path(path)) {
 975                 logger(mesh, MESHLINK_ERROR, "Failed to sync `%s': %s", path, strerror(errno));
 976                 meshlink_errno = MESHLINK_ESTORAGE;
 977                 return false;
 978         }
 979
 980         return true;
 981 }
 982
 983 /// Purge old invitation files
 984 size_t invitation_purge_old(meshlink_handle_t *mesh, time_t deadline) {
 985         if(!mesh->confbase) {
 986                 return true;
 987         }
 988
 989         char path[PATH_MAX];
 990         make_invitation_path(mesh, "current", "", path, sizeof(path));
 991
 992         DIR *dir = opendir(path);
 993
 994         if(!dir) {
 995                 logger(mesh, MESHLINK_DEBUG, "Could not read directory %s: %s\n", path, strerror(errno));
 996                 meshlink_errno = MESHLINK_ESTORAGE;
 997                 return 0;
 998         }
 999
1000         errno = 0;
1001         size_t count = 0;
1002         struct dirent *ent;
1003
1004         while((ent = readdir(dir))) {
1005                 if(strlen(ent->d_name) != 24) {
1006                         continue;
1007                 }
1008
1009                 char invname[PATH_MAX];
1010                 struct stat st;
1011
1012                 if(snprintf(invname, sizeof(invname), "%s" SLASH "%s", path, ent->d_name) >= PATH_MAX) {
1013                         logger(mesh, MESHLINK_DEBUG, "Filename too long: %s" SLASH "%s", path, ent->d_name);
1014                         continue;
1015                 }
1016
1017                 if(!stat(invname, &st)) {
1018                         if(mesh->invitation_key && deadline < st.st_mtime) {
1019                                 count++;
1020                         } else {
1021                                 unlink(invname);
1022                         }
1023                 } else {
1024                         logger(mesh, MESHLINK_DEBUG, "Could not stat %s: %s\n", invname, strerror(errno));
1025                         errno = 0;
1026                 }
1027         }
1028
1029         if(errno) {
1030                 logger(mesh, MESHLINK_DEBUG, "Error while reading directory %s: %s\n", path, strerror(errno));
1031                 closedir(dir);
1032                 meshlink_errno = MESHLINK_ESTORAGE;
1033                 return 0;
1034         }
1035
1036         closedir(dir);
1037
1038         return count;
1039 }
1040
1041 /// Purge invitations for the given node
1042 size_t invitation_purge_node(meshlink_handle_t *mesh, const char *node_name) {
1043         if(!mesh->confbase) {
1044                 return true;
1045         }
1046
1047         char path[PATH_MAX];
1048         make_invitation_path(mesh, "current", "", path, sizeof(path));
1049
1050         DIR *dir = opendir(path);
1051
1052         if(!dir) {
1053                 logger(mesh, MESHLINK_DEBUG, "Could not read directory %s: %s\n", path, strerror(errno));
1054                 meshlink_errno = MESHLINK_ESTORAGE;
1055                 return 0;
1056         }
1057
1058         errno = 0;
1059         size_t count = 0;
1060         struct dirent *ent;
1061
1062         while((ent = readdir(dir))) {
1063                 if(strlen(ent->d_name) != 24) {
1064                         continue;
1065                 }
1066
1067                 char invname[PATH_MAX];
1068
1069                 if(snprintf(invname, sizeof(invname), "%s" SLASH "%s", path, ent->d_name) >= PATH_MAX) {
1070                         logger(mesh, MESHLINK_DEBUG, "Filename too long: %s" SLASH "%s", path, ent->d_name);
1071                         continue;
1072                 }
1073
1074                 FILE *f = fopen(invname, "r");
1075
1076                 if(!f) {
1077                         errno = 0;
1078                         continue;
1079                 }
1080
1081                 config_t config;
1082
1083                 if(!config_read_file(mesh, f, &config, mesh->config_key)) {
1084                         logger(mesh, MESHLINK_ERROR, "Failed to read `%s': %s", invname, strerror(errno));
1085                         config_free(&config);
1086                         fclose(f);
1087                         errno = 0;
1088                         continue;
1089                 }
1090
1091                 packmsg_input_t in = {config.buf, config.len};
1092                 packmsg_get_uint32(&in); // skip version
1093                 char *name = packmsg_get_str_dup(&in);
1094
1095                 if(name && !strcmp(name, node_name)) {
1096                         logger(mesh, MESHLINK_DEBUG, "Removing invitation for %s", node_name);
1097                         unlink(invname);
1098                 }
1099
1100                 free(name);
1101                 config_free(&config);
1102                 fclose(f);
1103         }
1104
1105         if(errno) {
1106                 logger(mesh, MESHLINK_DEBUG, "Error while reading directory %s: %s\n", path, strerror(errno));
1107                 closedir(dir);
1108                 meshlink_errno = MESHLINK_ESTORAGE;
1109                 return 0;
1110         }
1111
1112         closedir(dir);
1113
1114         return count;
1115 }