src/shared/install.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty <of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <fnmatch.h>
  27
  28 #include "util.h"
  29 #include "mkdir.h"
  30 #include "hashmap.h"
  31 #include "set.h"
  32 #include "path-util.h"
  33 #include "path-lookup.h"
  34 #include "strv.h"
  35 #include "unit-name.h"
  36 #include "install.h"
  37 #include "conf-parser.h"
  38 #include "conf-files.h"
  39 #include "install-printf.h"
  40 #include "special.h"
  41
  42 typedef struct {
  43         OrderedHashmap *will_install;
  44         OrderedHashmap *have_installed;
  45 } InstallContext;
  46
  47 static int in_search_path(const char *path, char **search) {
  48         _cleanup_free_ char *parent = NULL;
  49         int r;
  50
  51         assert(path);
  52
  53         r = path_get_parent(path, &parent);
  54         if (r < 0)
  55                 return r;
  56
  57         return strv_contains(search, parent);
  58 }
  59
  60 static int get_config_path(UnitFileScope scope, bool runtime, const char *root_dir, char **ret) {
  61         char *p = NULL;
  62         int r;
  63
  64         assert(scope >= 0);
  65         assert(scope < _UNIT_FILE_SCOPE_MAX);
  66         assert(ret);
  67
  68         switch (scope) {
  69
  70         case UNIT_FILE_SYSTEM:
  71
  72                 if (runtime)
  73                         p = path_join(root_dir, "/run/systemd/system", NULL);
  74                 else
  75                         p = path_join(root_dir, SYSTEM_CONFIG_UNIT_PATH, NULL);
  76                 break;
  77
  78         case UNIT_FILE_GLOBAL:
  79
  80                 if (root_dir)
  81                         return -EINVAL;
  82
  83                 if (runtime)
  84                         p = strdup("/run/systemd/user");
  85                 else
  86                         p = strdup(USER_CONFIG_UNIT_PATH);
  87                 break;
  88
  89         case UNIT_FILE_USER:
  90
  91                 if (root_dir)
  92                         return -EINVAL;
  93
  94                 if (runtime)
  95                         r = user_runtime_dir(&p);
  96                 else
  97                         r = user_config_home(&p);
  98
  99                 if (r <= 0)
 100                         return r < 0 ? r : -ENOENT;
 101
 102                 break;
 103
 104         default:
 105                 assert_not_reached("Bad scope");
 106         }
 107
 108         if (!p)
 109                 return -ENOMEM;
 110
 111         *ret = p;
 112         return 0;
 113 }
 114
 115 static int add_file_change(
 116                 UnitFileChange **changes,
 117                 unsigned *n_changes,
 118                 UnitFileChangeType type,
 119                 const char *path,
 120                 const char *source) {
 121
 122         UnitFileChange *c;
 123         unsigned i;
 124
 125         assert(path);
 126         assert(!changes == !n_changes);
 127
 128         if (!changes)
 129                 return 0;
 130
 131         c = realloc(*changes, (*n_changes + 1) * sizeof(UnitFileChange));
 132         if (!c)
 133                 return -ENOMEM;
 134
 135         *changes = c;
 136         i = *n_changes;
 137
 138         c[i].type = type;
 139         c[i].path = strdup(path);
 140         if (!c[i].path)
 141                 return -ENOMEM;
 142
 143         path_kill_slashes(c[i].path);
 144
 145         if (source) {
 146                 c[i].source = strdup(source);
 147                 if (!c[i].source) {
 148                         free(c[i].path);
 149                         return -ENOMEM;
 150                 }
 151
 152                 path_kill_slashes(c[i].path);
 153         } else
 154                 c[i].source = NULL;
 155
 156         *n_changes = i+1;
 157         return 0;
 158 }
 159
 160 static int mark_symlink_for_removal(
 161                 Set **remove_symlinks_to,
 162                 const char *p) {
 163
 164         char *n;
 165         int r;
 166
 167         assert(p);
 168
 169         r = set_ensure_allocated(remove_symlinks_to, &string_hash_ops);
 170         if (r < 0)
 171                 return r;
 172
 173         n = strdup(p);
 174         if (!n)
 175                 return -ENOMEM;
 176
 177         path_kill_slashes(n);
 178
 179         r = set_consume(*remove_symlinks_to, n);
 180         if (r < 0)
 181                 return r == -EEXIST ? 0 : r;
 182
 183         return 0;
 184 }
 185
 186 static int remove_marked_symlinks_fd(
 187                 Set *remove_symlinks_to,
 188                 int fd,
 189                 const char *path,
 190                 const char *config_path,
 191                 bool *deleted,
 192                 UnitFileChange **changes,
 193                 unsigned *n_changes,
 194                 char** instance_whitelist) {
 195
 196         _cleanup_closedir_ DIR *d = NULL;
 197         int r = 0;
 198
 199         assert(remove_symlinks_to);
 200         assert(fd >= 0);
 201         assert(path);
 202         assert(config_path);
 203         assert(deleted);
 204
 205         d = fdopendir(fd);
 206         if (!d) {
 207                 safe_close(fd);
 208                 return -errno;
 209         }
 210
 211         rewinddir(d);
 212
 213         for (;;) {
 214                 struct dirent *de;
 215
 216                 errno = 0;
 217                 de = readdir(d);
 218                 if (!de && errno != 0) {
 219                         r = -errno;
 220                         break;
 221                 }
 222
 223                 if (!de)
 224                         break;
 225
 226                 if (hidden_file(de->d_name))
 227                         continue;
 228
 229                 dirent_ensure_type(d, de);
 230
 231                 if (de->d_type == DT_DIR) {
 232                         int nfd, q;
 233                         _cleanup_free_ char *p = NULL;
 234
 235                         nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
 236                         if (nfd < 0) {
 237                                 if (errno == ENOENT)
 238                                         continue;
 239
 240                                 if (r == 0)
 241                                         r = -errno;
 242                                 continue;
 243                         }
 244
 245                         p = path_make_absolute(de->d_name, path);
 246                         if (!p) {
 247                                 safe_close(nfd);
 248                                 return -ENOMEM;
 249                         }
 250
 251                         /* This will close nfd, regardless whether it succeeds or not */
 252                         q = remove_marked_symlinks_fd(remove_symlinks_to, nfd, p, config_path, deleted, changes, n_changes, instance_whitelist);
 253                         if (q < 0 && r == 0)
 254                                 r = q;
 255
 256                 } else if (de->d_type == DT_LNK) {
 257                         _cleanup_free_ char *p = NULL, *dest = NULL;
 258                         int q;
 259                         bool found;
 260
 261                         if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
 262                                 continue;
 263
 264                         if (unit_name_is_instance(de->d_name) &&
 265                             instance_whitelist &&
 266                             !strv_contains(instance_whitelist, de->d_name)) {
 267
 268                                 _cleanup_free_ char *w;
 269
 270                                 /* OK, the file is not listed directly
 271                                  * in the whitelist, so let's check if
 272                                  * the template of it might be
 273                                  * listed. */
 274
 275                                 w = unit_name_template(de->d_name);
 276                                 if (!w)
 277                                         return -ENOMEM;
 278
 279                                 if (!strv_contains(instance_whitelist, w))
 280                                         continue;
 281                         }
 282
 283                         p = path_make_absolute(de->d_name, path);
 284                         if (!p)
 285                                 return -ENOMEM;
 286
 287                         q = readlink_and_canonicalize(p, &dest);
 288                         if (q < 0) {
 289                                 if (q == -ENOENT)
 290                                         continue;
 291
 292                                 if (r == 0)
 293                                         r = q;
 294                                 continue;
 295                         }
 296
 297                         found =
 298                                 set_get(remove_symlinks_to, dest) ||
 299                                 set_get(remove_symlinks_to, basename(dest));
 300
 301                         if (!found)
 302                                 continue;
 303
 304                         if (unlink(p) < 0 && errno != ENOENT) {
 305                                 if (r == 0)
 306                                         r = -errno;
 307                                 continue;
 308                         }
 309
 310                         path_kill_slashes(p);
 311                         rmdir_parents(p, config_path);
 312                         add_file_change(changes, n_changes, UNIT_FILE_UNLINK, p, NULL);
 313
 314                         if (!set_get(remove_symlinks_to, p)) {
 315
 316                                 q = mark_symlink_for_removal(&remove_symlinks_to, p);
 317                                 if (q < 0) {
 318                                         if (r == 0)
 319                                                 r = q;
 320                                 } else
 321                                         *deleted = true;
 322                         }
 323                 }
 324         }
 325
 326         return r;
 327 }
 328
 329 static int remove_marked_symlinks(
 330                 Set *remove_symlinks_to,
 331                 const char *config_path,
 332                 UnitFileChange **changes,
 333                 unsigned *n_changes,
 334                 char** instance_whitelist) {
 335
 336         _cleanup_close_ int fd = -1;
 337         int r = 0;
 338         bool deleted;
 339
 340         assert(config_path);
 341
 342         if (set_size(remove_symlinks_to) <= 0)
 343                 return 0;
 344
 345         fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
 346         if (fd < 0)
 347                 return -errno;
 348
 349         do {
 350                 int q, cfd;
 351                 deleted = false;
 352
 353                 cfd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 354                 if (cfd < 0) {
 355                         r = -errno;
 356                         break;
 357                 }
 358
 359                 /* This takes possession of cfd and closes it */
 360                 q = remove_marked_symlinks_fd(remove_symlinks_to, cfd, config_path, config_path, &deleted, changes, n_changes, instance_whitelist);
 361                 if (r == 0)
 362                         r = q;
 363         } while (deleted);
 364
 365         return r;
 366 }
 367
 368 static int find_symlinks_fd(
 369                 const char *name,
 370                 int fd,
 371                 const char *path,
 372                 const char *config_path,
 373                 bool *same_name_link) {
 374
 375         int r = 0;
 376         _cleanup_closedir_ DIR *d = NULL;
 377
 378         assert(name);
 379         assert(fd >= 0);
 380         assert(path);
 381         assert(config_path);
 382         assert(same_name_link);
 383
 384         d = fdopendir(fd);
 385         if (!d) {
 386                 safe_close(fd);
 387                 return -errno;
 388         }
 389
 390         for (;;) {
 391                 struct dirent *de;
 392
 393                 errno = 0;
 394                 de = readdir(d);
 395                 if (!de && errno != 0)
 396                         return -errno;
 397
 398                 if (!de)
 399                         return r;
 400
 401                 if (hidden_file(de->d_name))
 402                         continue;
 403
 404                 dirent_ensure_type(d, de);
 405
 406                 if (de->d_type == DT_DIR) {
 407                         int nfd, q;
 408                         _cleanup_free_ char *p = NULL;
 409
 410                         nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
 411                         if (nfd < 0) {
 412                                 if (errno == ENOENT)
 413                                         continue;
 414
 415                                 if (r == 0)
 416                                         r = -errno;
 417                                 continue;
 418                         }
 419
 420                         p = path_make_absolute(de->d_name, path);
 421                         if (!p) {
 422                                 safe_close(nfd);
 423                                 return -ENOMEM;
 424                         }
 425
 426                         /* This will close nfd, regardless whether it succeeds or not */
 427                         q = find_symlinks_fd(name, nfd, p, config_path, same_name_link);
 428                         if (q > 0)
 429                                 return 1;
 430                         if (r == 0)
 431                                 r = q;
 432
 433                 } else if (de->d_type == DT_LNK) {
 434                         _cleanup_free_ char *p = NULL, *dest = NULL;
 435                         bool found_path, found_dest, b = false;
 436                         int q;
 437
 438                         /* Acquire symlink name */
 439                         p = path_make_absolute(de->d_name, path);
 440                         if (!p)
 441                                 return -ENOMEM;
 442
 443                         /* Acquire symlink destination */
 444                         q = readlink_and_canonicalize(p, &dest);
 445                         if (q < 0) {
 446                                 if (q == -ENOENT)
 447                                         continue;
 448
 449                                 if (r == 0)
 450                                         r = q;
 451                                 continue;
 452                         }
 453
 454                         /* Check if the symlink itself matches what we
 455                          * are looking for */
 456                         if (path_is_absolute(name))
 457                                 found_path = path_equal(p, name);
 458                         else
 459                                 found_path = streq(de->d_name, name);
 460
 461                         /* Check if what the symlink points to
 462                          * matches what we are looking for */
 463                         if (path_is_absolute(name))
 464                                 found_dest = path_equal(dest, name);
 465                         else
 466                                 found_dest = streq(basename(dest), name);
 467
 468                         if (found_path && found_dest) {
 469                                 _cleanup_free_ char *t = NULL;
 470
 471                                 /* Filter out same name links in the main
 472                                  * config path */
 473                                 t = path_make_absolute(name, config_path);
 474                                 if (!t)
 475                                         return -ENOMEM;
 476
 477                                 b = path_equal(t, p);
 478                         }
 479
 480                         if (b)
 481                                 *same_name_link = true;
 482                         else if (found_path || found_dest)
 483                                 return 1;
 484                 }
 485         }
 486 }
 487
 488 static int find_symlinks(
 489                 const char *name,
 490                 const char *config_path,
 491                 bool *same_name_link) {
 492
 493         int fd;
 494
 495         assert(name);
 496         assert(config_path);
 497         assert(same_name_link);
 498
 499         fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
 500         if (fd < 0) {
 501                 if (errno == ENOENT)
 502                         return 0;
 503                 return -errno;
 504         }
 505
 506         /* This takes possession of fd and closes it */
 507         return find_symlinks_fd(name, fd, config_path, config_path, same_name_link);
 508 }
 509
 510 static int find_symlinks_in_scope(
 511                 UnitFileScope scope,
 512                 const char *root_dir,
 513                 const char *name,
 514                 UnitFileState *state) {
 515
 516         int r;
 517         _cleanup_free_ char *path = NULL;
 518         bool same_name_link_runtime = false, same_name_link = false;
 519
 520         assert(scope >= 0);
 521         assert(scope < _UNIT_FILE_SCOPE_MAX);
 522         assert(name);
 523
 524         /* First look in runtime config path */
 525         r = get_config_path(scope, true, root_dir, &path);
 526         if (r < 0)
 527                 return r;
 528
 529         r = find_symlinks(name, path, &same_name_link_runtime);
 530         if (r < 0)
 531                 return r;
 532         else if (r > 0) {
 533                 *state = UNIT_FILE_ENABLED_RUNTIME;
 534                 return r;
 535         }
 536
 537         /* Then look in the normal config path */
 538         r = get_config_path(scope, false, root_dir, &path);
 539         if (r < 0)
 540                 return r;
 541
 542         r = find_symlinks(name, path, &same_name_link);
 543         if (r < 0)
 544                 return r;
 545         else if (r > 0) {
 546                 *state = UNIT_FILE_ENABLED;
 547                 return r;
 548         }
 549
 550         /* Hmm, we didn't find it, but maybe we found the same name
 551          * link? */
 552         if (same_name_link_runtime) {
 553                 *state = UNIT_FILE_LINKED_RUNTIME;
 554                 return 1;
 555         } else if (same_name_link) {
 556                 *state = UNIT_FILE_LINKED;
 557                 return 1;
 558         }
 559
 560         return 0;
 561 }
 562
 563 int unit_file_mask(
 564                 UnitFileScope scope,
 565                 bool runtime,
 566                 const char *root_dir,
 567                 char **files,
 568                 bool force,
 569                 UnitFileChange **changes,
 570                 unsigned *n_changes) {
 571
 572         char **i;
 573         _cleanup_free_ char *prefix = NULL;
 574         int r;
 575
 576         assert(scope >= 0);
 577         assert(scope < _UNIT_FILE_SCOPE_MAX);
 578
 579         r = get_config_path(scope, runtime, root_dir, &prefix);
 580         if (r < 0)
 581                 return r;
 582
 583         STRV_FOREACH(i, files) {
 584                 _cleanup_free_ char *path = NULL;
 585
 586                 if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
 587                         if (r == 0)
 588                                 r = -EINVAL;
 589                         continue;
 590                 }
 591
 592                 path = path_make_absolute(*i, prefix);
 593                 if (!path) {
 594                         r = -ENOMEM;
 595                         break;
 596                 }
 597
 598                 if (symlink("/dev/null", path) >= 0) {
 599                         add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
 600                         continue;
 601                 }
 602
 603                 if (errno == EEXIST) {
 604
 605                         if (null_or_empty_path(path) > 0)
 606                                 continue;
 607
 608                         if (force) {
 609                                 if (symlink_atomic("/dev/null", path) >= 0) {
 610                                         add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
 611                                         add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
 612                                         continue;
 613                                 }
 614                         }
 615
 616                         if (r == 0)
 617                                 r = -EEXIST;
 618                 } else {
 619                         if (r == 0)
 620                                 r = -errno;
 621                 }
 622         }
 623
 624         return r;
 625 }
 626
 627 int unit_file_unmask(
 628                 UnitFileScope scope,
 629                 bool runtime,
 630                 const char *root_dir,
 631                 char **files,
 632                 UnitFileChange **changes,
 633                 unsigned *n_changes) {
 634
 635         char **i, *config_path = NULL;
 636         int r, q;
 637         Set *remove_symlinks_to = NULL;
 638
 639         assert(scope >= 0);
 640         assert(scope < _UNIT_FILE_SCOPE_MAX);
 641
 642         r = get_config_path(scope, runtime, root_dir, &config_path);
 643         if (r < 0)
 644                 goto finish;
 645
 646         STRV_FOREACH(i, files) {
 647                 _cleanup_free_ char *path = NULL;
 648
 649                 if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
 650                         if (r == 0)
 651                                 r = -EINVAL;
 652                         continue;
 653                 }
 654
 655                 path = path_make_absolute(*i, config_path);
 656                 if (!path) {
 657                         r = -ENOMEM;
 658                         break;
 659                 }
 660
 661                 q = null_or_empty_path(path);
 662                 if (q > 0) {
 663                         if (unlink(path) < 0)
 664                                 q = -errno;
 665                         else {
 666                                 q = mark_symlink_for_removal(&remove_symlinks_to, path);
 667                                 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
 668                         }
 669                 }
 670
 671                 if (q != -ENOENT && r == 0)
 672                         r = q;
 673         }
 674
 675
 676 finish:
 677         q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
 678         if (r == 0)
 679                 r = q;
 680
 681         set_free_free(remove_symlinks_to);
 682         free(config_path);
 683
 684         return r;
 685 }
 686
 687 int unit_file_link(
 688                 UnitFileScope scope,
 689                 bool runtime,
 690                 const char *root_dir,
 691                 char **files,
 692                 bool force,
 693                 UnitFileChange **changes,
 694                 unsigned *n_changes) {
 695
 696         _cleanup_lookup_paths_free_ LookupPaths paths = {};
 697         char **i;
 698         _cleanup_free_ char *config_path = NULL;
 699         int r, q;
 700
 701         assert(scope >= 0);
 702         assert(scope < _UNIT_FILE_SCOPE_MAX);
 703
 704         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
 705         if (r < 0)
 706                 return r;
 707
 708         r = get_config_path(scope, runtime, root_dir, &config_path);
 709         if (r < 0)
 710                 return r;
 711
 712         STRV_FOREACH(i, files) {
 713                 _cleanup_free_ char *path = NULL;
 714                 char *fn;
 715                 struct stat st;
 716
 717                 fn = basename(*i);
 718
 719                 if (!path_is_absolute(*i) ||
 720                     !unit_name_is_valid(fn, TEMPLATE_VALID)) {
 721                         if (r == 0)
 722                                 r = -EINVAL;
 723                         continue;
 724                 }
 725
 726                 if (lstat(*i, &st) < 0) {
 727                         if (r == 0)
 728                                 r = -errno;
 729                         continue;
 730                 }
 731
 732                 if (!S_ISREG(st.st_mode)) {
 733                         r = -ENOENT;
 734                         continue;
 735                 }
 736
 737                 q = in_search_path(*i, paths.unit_path);
 738                 if (q < 0)
 739                         return q;
 740
 741                 if (q > 0)
 742                         continue;
 743
 744                 path = path_make_absolute(fn, config_path);
 745                 if (!path)
 746                         return -ENOMEM;
 747
 748                 if (symlink(*i, path) >= 0) {
 749                         add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
 750                         continue;
 751                 }
 752
 753                 if (errno == EEXIST) {
 754                         _cleanup_free_ char *dest = NULL;
 755
 756                         q = readlink_and_make_absolute(path, &dest);
 757                         if (q < 0 && errno != ENOENT) {
 758                                 if (r == 0)
 759                                         r = q;
 760                                 continue;
 761                         }
 762
 763                         if (q >= 0 && path_equal(dest, *i))
 764                                 continue;
 765
 766                         if (force) {
 767                                 if (symlink_atomic(*i, path) >= 0) {
 768                                         add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
 769                                         add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
 770                                         continue;
 771                                 }
 772                         }
 773
 774                         if (r == 0)
 775                                 r = -EEXIST;
 776                 } else {
 777                         if (r == 0)
 778                                 r = -errno;
 779                 }
 780         }
 781
 782         return r;
 783 }
 784
 785 void unit_file_list_free(Hashmap *h) {
 786         UnitFileList *i;
 787
 788         while ((i = hashmap_steal_first(h))) {
 789                 free(i->path);
 790                 free(i);
 791         }
 792
 793         hashmap_free(h);
 794 }
 795
 796 void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes) {
 797         unsigned i;
 798
 799         assert(changes || n_changes == 0);
 800
 801         if (!changes)
 802                 return;
 803
 804         for (i = 0; i < n_changes; i++) {
 805                 free(changes[i].path);
 806                 free(changes[i].source);
 807         }
 808
 809         free(changes);
 810 }
 811
 812 static void install_info_free(InstallInfo *i) {
 813         assert(i);
 814
 815         free(i->name);
 816         free(i->path);
 817         strv_free(i->aliases);
 818         strv_free(i->wanted_by);
 819         strv_free(i->required_by);
 820         strv_free(i->also);
 821         free(i->default_instance);
 822         free(i);
 823 }
 824
 825 static void install_info_hashmap_free(OrderedHashmap *m) {
 826         InstallInfo *i;
 827
 828         if (!m)
 829                 return;
 830
 831         while ((i = ordered_hashmap_steal_first(m)))
 832                 install_info_free(i);
 833
 834         ordered_hashmap_free(m);
 835 }
 836
 837 static void install_context_done(InstallContext *c) {
 838         assert(c);
 839
 840         install_info_hashmap_free(c->will_install);
 841         install_info_hashmap_free(c->have_installed);
 842
 843         c->will_install = c->have_installed = NULL;
 844 }
 845
 846 static int install_info_add(
 847                 InstallContext *c,
 848                 const char *name,
 849                 const char *path) {
 850         InstallInfo *i = NULL;
 851         int r;
 852
 853         assert(c);
 854         assert(name || path);
 855
 856         if (!name)
 857                 name = basename(path);
 858
 859         if (!unit_name_is_valid(name, TEMPLATE_VALID))
 860                 return -EINVAL;
 861
 862         if (ordered_hashmap_get(c->have_installed, name) ||
 863             ordered_hashmap_get(c->will_install, name))
 864                 return 0;
 865
 866         r = ordered_hashmap_ensure_allocated(&c->will_install, &string_hash_ops);
 867         if (r < 0)
 868                 return r;
 869
 870         i = new0(InstallInfo, 1);
 871         if (!i)
 872                 return -ENOMEM;
 873
 874         i->name = strdup(name);
 875         if (!i->name) {
 876                 r = -ENOMEM;
 877                 goto fail;
 878         }
 879
 880         if (path) {
 881                 i->path = strdup(path);
 882                 if (!i->path) {
 883                         r = -ENOMEM;
 884                         goto fail;
 885                 }
 886         }
 887
 888         r = ordered_hashmap_put(c->will_install, i->name, i);
 889         if (r < 0)
 890                 goto fail;
 891
 892         return 0;
 893
 894 fail:
 895         if (i)
 896                 install_info_free(i);
 897
 898         return r;
 899 }
 900
 901 static int install_info_add_auto(
 902                 InstallContext *c,
 903                 const char *name_or_path) {
 904
 905         assert(c);
 906         assert(name_or_path);
 907
 908         if (path_is_absolute(name_or_path))
 909                 return install_info_add(c, NULL, name_or_path);
 910         else
 911                 return install_info_add(c, name_or_path, NULL);
 912 }
 913
 914 static int config_parse_also(
 915                 const char *unit,
 916                 const char *filename,
 917                 unsigned line,
 918                 const char *section,
 919                 unsigned section_line,
 920                 const char *lvalue,
 921                 int ltype,
 922                 const char *rvalue,
 923                 void *data,
 924                 void *userdata) {
 925
 926         size_t l;
 927         const char *word, *state;
 928         InstallContext *c = data;
 929         InstallInfo *i = userdata;
 930
 931         assert(filename);
 932         assert(lvalue);
 933         assert(rvalue);
 934
 935         FOREACH_WORD_QUOTED(word, l, rvalue, state) {
 936                 _cleanup_free_ char *n;
 937                 int r;
 938
 939                 n = strndup(word, l);
 940                 if (!n)
 941                         return -ENOMEM;
 942
 943                 r = install_info_add(c, n, NULL);
 944                 if (r < 0)
 945                         return r;
 946
 947                 r = strv_extend(&i->also, n);
 948                 if (r < 0)
 949                         return r;
 950         }
 951         if (!isempty(state))
 952                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 953                            "Trailing garbage, ignoring.");
 954
 955         return 0;
 956 }
 957
 958 static int config_parse_user(
 959                 const char *unit,
 960                 const char *filename,
 961                 unsigned line,
 962                 const char *section,
 963                 unsigned section_line,
 964                 const char *lvalue,
 965                 int ltype,
 966                 const char *rvalue,
 967                 void *data,
 968                 void *userdata) {
 969
 970         InstallInfo *i = data;
 971         char *printed;
 972         int r;
 973
 974         assert(filename);
 975         assert(lvalue);
 976         assert(rvalue);
 977
 978         r = install_full_printf(i, rvalue, &printed);
 979         if (r < 0)
 980                 return r;
 981
 982         free(i->user);
 983         i->user = printed;
 984
 985         return 0;
 986 }
 987
 988 static int config_parse_default_instance(
 989                 const char *unit,
 990                 const char *filename,
 991                 unsigned line,
 992                 const char *section,
 993                 unsigned section_line,
 994                 const char *lvalue,
 995                 int ltype,
 996                 const char *rvalue,
 997                 void *data,
 998                 void *userdata) {
 999
1000         InstallInfo *i = data;
1001         char *printed;
1002         int r;
1003
1004         assert(filename);
1005         assert(lvalue);
1006         assert(rvalue);
1007
1008         r = install_full_printf(i, rvalue, &printed);
1009         if (r < 0)
1010                 return r;
1011
1012         if (!unit_instance_is_valid(printed)) {
1013                 free(printed);
1014                 return -EINVAL;
1015         }
1016
1017         free(i->default_instance);
1018         i->default_instance = printed;
1019
1020         return 0;
1021 }
1022
1023 static int unit_file_load(
1024                 InstallContext *c,
1025                 InstallInfo *info,
1026                 const char *path,
1027                 const char *root_dir,
1028                 bool allow_symlink,
1029                 bool load,
1030                 bool *also) {
1031
1032         const ConfigTableItem items[] = {
1033                 { "Install", "Alias",           config_parse_strv,             0, &info->aliases           },
1034                 { "Install", "WantedBy",        config_parse_strv,             0, &info->wanted_by         },
1035                 { "Install", "RequiredBy",      config_parse_strv,             0, &info->required_by       },
1036                 { "Install", "DefaultInstance", config_parse_default_instance, 0, info                     },
1037                 { "Install", "Also",            config_parse_also,             0, c                        },
1038                 { "Exec",    "User",            config_parse_user,             0, info                     },
1039                 {}
1040         };
1041
1042         _cleanup_fclose_ FILE *f = NULL;
1043         int fd, r;
1044
1045         assert(c);
1046         assert(info);
1047         assert(path);
1048
1049         if (!isempty(root_dir))
1050                 path = strjoina(root_dir, "/", path);
1051
1052         if (!load) {
1053                 r = access(path, F_OK) ? -errno : 0;
1054                 return r;
1055         }
1056
1057         fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|(allow_symlink ? 0 : O_NOFOLLOW));
1058         if (fd < 0)
1059                 return -errno;
1060
1061         f = fdopen(fd, "re");
1062         if (!f) {
1063                 safe_close(fd);
1064                 return -ENOMEM;
1065         }
1066
1067         r = config_parse(NULL, path, f,
1068                          NULL,
1069                          config_item_table_lookup, items,
1070                          true, true, false, info);
1071         if (r < 0)
1072                 return r;
1073
1074         if (also)
1075                 *also = !strv_isempty(info->also);
1076
1077         return
1078                 (int) strv_length(info->aliases) +
1079                 (int) strv_length(info->wanted_by) +
1080                 (int) strv_length(info->required_by);
1081 }
1082
1083 static int unit_file_search(
1084                 InstallContext *c,
1085                 InstallInfo *info,
1086                 LookupPaths *paths,
1087                 const char *root_dir,
1088                 bool allow_symlink,
1089                 bool load,
1090                 bool *also) {
1091
1092         char **p;
1093         int r;
1094
1095         assert(c);
1096         assert(info);
1097         assert(paths);
1098
1099         if (info->path)
1100                 return unit_file_load(c, info, info->path, root_dir, allow_symlink, load, also);
1101
1102         assert(info->name);
1103
1104         STRV_FOREACH(p, paths->unit_path) {
1105                 _cleanup_free_ char *path = NULL;
1106
1107                 path = strjoin(*p, "/", info->name, NULL);
1108                 if (!path)
1109                         return -ENOMEM;
1110
1111                 r = unit_file_load(c, info, path, root_dir, allow_symlink, load, also);
1112                 if (r >= 0) {
1113                         info->path = path;
1114                         path = NULL;
1115                         return r;
1116                 }
1117                 if (r != -ENOENT && r != -ELOOP)
1118                         return r;
1119         }
1120
1121         if (unit_name_is_instance(info->name)) {
1122
1123                 /* Unit file doesn't exist, however instance
1124                  * enablement was requested.  We will check if it is
1125                  * possible to load template unit file. */
1126
1127                 _cleanup_free_ char *template = NULL;
1128
1129                 template = unit_name_template(info->name);
1130                 if (!template)
1131                         return -ENOMEM;
1132
1133                 STRV_FOREACH(p, paths->unit_path) {
1134                         _cleanup_free_ char *path = NULL;
1135
1136                         path = strjoin(*p, "/", template, NULL);
1137                         if (!path)
1138                                 return -ENOMEM;
1139
1140                         r = unit_file_load(c, info, path, root_dir, allow_symlink, load, also);
1141                         if (r >= 0) {
1142                                 info->path = path;
1143                                 path = NULL;
1144                                 return r;
1145                         }
1146                         if (r != -ENOENT && r != -ELOOP)
1147                                 return r;
1148                 }
1149         }
1150
1151         return -ENOENT;
1152 }
1153
1154 static int unit_file_can_install(
1155                 LookupPaths *paths,
1156                 const char *root_dir,
1157                 const char *name,
1158                 bool allow_symlink,
1159                 bool *also) {
1160
1161         _cleanup_(install_context_done) InstallContext c = {};
1162         InstallInfo *i;
1163         int r;
1164
1165         assert(paths);
1166         assert(name);
1167
1168         r = install_info_add_auto(&c, name);
1169         if (r < 0)
1170                 return r;
1171
1172         assert_se(i = ordered_hashmap_first(c.will_install));
1173
1174         r = unit_file_search(&c, i, paths, root_dir, allow_symlink, true, also);
1175
1176         if (r >= 0)
1177                 r =
1178                         (int) strv_length(i->aliases) +
1179                         (int) strv_length(i->wanted_by) +
1180                         (int) strv_length(i->required_by);
1181
1182         return r;
1183 }
1184
1185 static int create_symlink(
1186                 const char *old_path,
1187                 const char *new_path,
1188                 bool force,
1189                 UnitFileChange **changes,
1190                 unsigned *n_changes) {
1191
1192         _cleanup_free_ char *dest = NULL;
1193         int r;
1194
1195         assert(old_path);
1196         assert(new_path);
1197
1198         mkdir_parents_label(new_path, 0755);
1199
1200         if (symlink(old_path, new_path) >= 0) {
1201                 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
1202                 return 0;
1203         }
1204
1205         if (errno != EEXIST)
1206                 return -errno;
1207
1208         r = readlink_and_make_absolute(new_path, &dest);
1209         if (r < 0)
1210                 return r;
1211
1212         if (path_equal(dest, old_path))
1213                 return 0;
1214
1215         if (!force)
1216                 return -EEXIST;
1217
1218         r = symlink_atomic(old_path, new_path);
1219         if (r < 0)
1220                 return r;
1221
1222         add_file_change(changes, n_changes, UNIT_FILE_UNLINK, new_path, NULL);
1223         add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
1224
1225         return 0;
1226 }
1227
1228 static int install_info_symlink_alias(
1229                 InstallInfo *i,
1230                 const char *config_path,
1231                 bool force,
1232                 UnitFileChange **changes,
1233                 unsigned *n_changes) {
1234
1235         char **s;
1236         int r = 0, q;
1237
1238         assert(i);
1239         assert(config_path);
1240
1241         STRV_FOREACH(s, i->aliases) {
1242                 _cleanup_free_ char *alias_path = NULL, *dst = NULL;
1243
1244                 q = install_full_printf(i, *s, &dst);
1245                 if (q < 0)
1246                         return q;
1247
1248                 alias_path = path_make_absolute(dst, config_path);
1249                 if (!alias_path)
1250                         return -ENOMEM;
1251
1252                 q = create_symlink(i->path, alias_path, force, changes, n_changes);
1253                 if (r == 0)
1254                         r = q;
1255         }
1256
1257         return r;
1258 }
1259
1260 static int install_info_symlink_wants(
1261                 InstallInfo *i,
1262                 const char *config_path,
1263                 char **list,
1264                 const char *suffix,
1265                 bool force,
1266                 UnitFileChange **changes,
1267                 unsigned *n_changes) {
1268
1269         _cleanup_free_ char *buf = NULL;
1270         const char *n;
1271         char **s;
1272         int r = 0, q;
1273
1274         assert(i);
1275         assert(config_path);
1276
1277         if (unit_name_is_template(i->name)) {
1278
1279                 /* Don't install any symlink if there's no default
1280                  * instance configured */
1281
1282                 if (!i->default_instance)
1283                         return 0;
1284
1285                 buf = unit_name_replace_instance(i->name, i->default_instance);
1286                 if (!buf)
1287                         return -ENOMEM;
1288
1289                 n = buf;
1290         } else
1291                 n = i->name;
1292
1293         STRV_FOREACH(s, list) {
1294                 _cleanup_free_ char *path = NULL, *dst = NULL;
1295
1296                 q = install_full_printf(i, *s, &dst);
1297                 if (q < 0)
1298                         return q;
1299
1300                 if (!unit_name_is_valid(dst, TEMPLATE_VALID)) {
1301                         r = -EINVAL;
1302                         continue;
1303                 }
1304
1305                 path = strjoin(config_path, "/", dst, suffix, n, NULL);
1306                 if (!path)
1307                         return -ENOMEM;
1308
1309                 q = create_symlink(i->path, path, force, changes, n_changes);
1310                 if (r == 0)
1311                         r = q;
1312         }
1313
1314         return r;
1315 }
1316
1317 static int install_info_symlink_link(
1318                 InstallInfo *i,
1319                 LookupPaths *paths,
1320                 const char *config_path,
1321                 const char *root_dir,
1322                 bool force,
1323                 UnitFileChange **changes,
1324                 unsigned *n_changes) {
1325
1326         _cleanup_free_ char *path = NULL;
1327         int r;
1328
1329         assert(i);
1330         assert(paths);
1331         assert(config_path);
1332         assert(i->path);
1333
1334         r = in_search_path(i->path, paths->unit_path);
1335         if (r != 0)
1336                 return r;
1337
1338         path = strjoin(config_path, "/", i->name, NULL);
1339         if (!path)
1340                 return -ENOMEM;
1341
1342         return create_symlink(i->path, path, force, changes, n_changes);
1343 }
1344
1345 static int install_info_apply(
1346                 InstallInfo *i,
1347                 LookupPaths *paths,
1348                 const char *config_path,
1349                 const char *root_dir,
1350                 bool force,
1351                 UnitFileChange **changes,
1352                 unsigned *n_changes) {
1353
1354         int r, q;
1355
1356         assert(i);
1357         assert(paths);
1358         assert(config_path);
1359
1360         r = install_info_symlink_alias(i, config_path, force, changes, n_changes);
1361
1362         q = install_info_symlink_wants(i, config_path, i->wanted_by, ".wants/", force, changes, n_changes);
1363         if (r == 0)
1364                 r = q;
1365
1366         q = install_info_symlink_wants(i, config_path, i->required_by, ".requires/", force, changes, n_changes);
1367         if (r == 0)
1368                 r = q;
1369
1370         q = install_info_symlink_link(i, paths, config_path, root_dir, force, changes, n_changes);
1371         if (r == 0)
1372                 r = q;
1373
1374         return r;
1375 }
1376
1377 static int install_context_apply(
1378                 InstallContext *c,
1379                 LookupPaths *paths,
1380                 const char *config_path,
1381                 const char *root_dir,
1382                 bool force,
1383                 UnitFileChange **changes,
1384                 unsigned *n_changes) {
1385
1386         InstallInfo *i;
1387         int r, q;
1388
1389         assert(c);
1390         assert(paths);
1391         assert(config_path);
1392
1393         if (!ordered_hashmap_isempty(c->will_install)) {
1394                 r = ordered_hashmap_ensure_allocated(&c->have_installed, &string_hash_ops);
1395                 if (r < 0)
1396                         return r;
1397
1398                 r = ordered_hashmap_reserve(c->have_installed, ordered_hashmap_size(c->will_install));
1399                 if (r < 0)
1400                         return r;
1401         }
1402
1403         r = 0;
1404         while ((i = ordered_hashmap_first(c->will_install))) {
1405                 assert_se(ordered_hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
1406
1407                 q = unit_file_search(c, i, paths, root_dir, false, true, NULL);
1408                 if (q < 0) {
1409                         if (r >= 0)
1410                                 r = q;
1411
1412                         return r;
1413                 } else if (r >= 0)
1414                         r += q;
1415
1416                 q = install_info_apply(i, paths, config_path, root_dir, force, changes, n_changes);
1417                 if (r >= 0 && q < 0)
1418                         r = q;
1419         }
1420
1421         return r;
1422 }
1423
1424 static int install_context_mark_for_removal(
1425                 InstallContext *c,
1426                 LookupPaths *paths,
1427                 Set **remove_symlinks_to,
1428                 const char *config_path,
1429                 const char *root_dir) {
1430
1431         InstallInfo *i;
1432         int r, q;
1433
1434         assert(c);
1435         assert(paths);
1436         assert(config_path);
1437
1438         /* Marks all items for removal */
1439
1440         if (!ordered_hashmap_isempty(c->will_install)) {
1441                 r = ordered_hashmap_ensure_allocated(&c->have_installed, &string_hash_ops);
1442                 if (r < 0)
1443                         return r;
1444
1445                 r = ordered_hashmap_reserve(c->have_installed, ordered_hashmap_size(c->will_install));
1446                 if (r < 0)
1447                         return r;
1448         }
1449
1450         r = 0;
1451         while ((i = ordered_hashmap_first(c->will_install))) {
1452                 assert_se(ordered_hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
1453
1454                 q = unit_file_search(c, i, paths, root_dir, false, true, NULL);
1455                 if (q == -ENOENT) {
1456                         /* do nothing */
1457                 } else if (q < 0) {
1458                         if (r >= 0)
1459                                 r = q;
1460
1461                         return r;
1462                 } else if (r >= 0)
1463                         r += q;
1464
1465                 if (unit_name_is_instance(i->name)) {
1466                         char *unit_file;
1467
1468                         if (i->path) {
1469                                 unit_file = basename(i->path);
1470
1471                                 if (unit_name_is_instance(unit_file))
1472                                         /* unit file named as instance exists, thus all symlinks
1473                                          * pointing to it will be removed */
1474                                         q = mark_symlink_for_removal(remove_symlinks_to, i->name);
1475                                 else
1476                                         /* does not exist, thus we will mark for removal symlinks
1477                                          * to template unit file */
1478                                         q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
1479                         } else {
1480                                 /* If i->path is not set, it means that we didn't actually find
1481                                  * the unit file. But we can still remove symlinks to the
1482                                  * nonexistent template. */
1483                                 unit_file = unit_name_template(i->name);
1484                                 if (!unit_file)
1485                                         return log_oom();
1486
1487                                 q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
1488                                 free(unit_file);
1489                         }
1490                 } else
1491                         q = mark_symlink_for_removal(remove_symlinks_to, i->name);
1492
1493                 if (r >= 0 && q < 0)
1494                         r = q;
1495         }
1496
1497         return r;
1498 }
1499
1500 int unit_file_add_dependency(
1501                 UnitFileScope scope,
1502                 bool runtime,
1503                 const char *root_dir,
1504                 char **files,
1505                 char *target,
1506                 UnitDependency dep,
1507                 bool force,
1508                 UnitFileChange **changes,
1509                 unsigned *n_changes) {
1510
1511         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1512         _cleanup_(install_context_done) InstallContext c = {};
1513         _cleanup_free_ char *config_path = NULL;
1514         char **i;
1515         int r;
1516         InstallInfo *info;
1517
1518         assert(scope >= 0);
1519         assert(scope < _UNIT_FILE_SCOPE_MAX);
1520
1521         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1522         if (r < 0)
1523                 return r;
1524
1525         r = get_config_path(scope, runtime, root_dir, &config_path);
1526         if (r < 0)
1527                 return r;
1528
1529         STRV_FOREACH(i, files) {
1530                 UnitFileState state;
1531
1532                 state = unit_file_get_state(scope, root_dir, *i);
1533                 if (state < 0)
1534                         return log_error_errno(state, "Failed to get unit file state for %s: %m", *i);
1535
1536                 if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
1537                         log_error("Failed to enable unit: Unit %s is masked", *i);
1538                         return -EOPNOTSUPP;
1539                 }
1540
1541                 r = install_info_add_auto(&c, *i);
1542                 if (r < 0)
1543                         return r;
1544         }
1545
1546         if (!ordered_hashmap_isempty(c.will_install)) {
1547                 r = ordered_hashmap_ensure_allocated(&c.have_installed, &string_hash_ops);
1548                 if (r < 0)
1549                         return r;
1550
1551                 r = ordered_hashmap_reserve(c.have_installed, ordered_hashmap_size(c.will_install));
1552                 if (r < 0)
1553                         return r;
1554         }
1555
1556         while ((info = ordered_hashmap_first(c.will_install))) {
1557                 assert_se(ordered_hashmap_move_one(c.have_installed, c.will_install, info->name) == 0);
1558
1559                 r = unit_file_search(&c, info, &paths, root_dir, false, false, NULL);
1560                 if (r < 0)
1561                         return r;
1562
1563                 if (dep == UNIT_WANTS)
1564                         r = strv_extend(&info->wanted_by, target);
1565                 else if (dep == UNIT_REQUIRES)
1566                         r = strv_extend(&info->required_by, target);
1567                 else
1568                         r = -EINVAL;
1569
1570                 if (r < 0)
1571                         return r;
1572
1573                 r = install_info_apply(info, &paths, config_path, root_dir, force, changes, n_changes);
1574                 if (r < 0)
1575                         return r;
1576         }
1577
1578         return 0;
1579 }
1580
1581 int unit_file_enable(
1582                 UnitFileScope scope,
1583                 bool runtime,
1584                 const char *root_dir,
1585                 char **files,
1586                 bool force,
1587                 UnitFileChange **changes,
1588                 unsigned *n_changes) {
1589
1590         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1591         _cleanup_(install_context_done) InstallContext c = {};
1592         char **i;
1593         _cleanup_free_ char *config_path = NULL;
1594         int r;
1595
1596         assert(scope >= 0);
1597         assert(scope < _UNIT_FILE_SCOPE_MAX);
1598
1599         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1600         if (r < 0)
1601                 return r;
1602
1603         r = get_config_path(scope, runtime, root_dir, &config_path);
1604         if (r < 0)
1605                 return r;
1606
1607         STRV_FOREACH(i, files) {
1608                 UnitFileState state;
1609
1610                 /* We only want to know if this unit is masked, so we ignore
1611                  * errors from unit_file_get_state, deferring other checks.
1612                  * This allows templated units to be enabled on the fly. */
1613                 state = unit_file_get_state(scope, root_dir, *i);
1614                 if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
1615                         log_error("Failed to enable unit: Unit %s is masked", *i);
1616                         return -EOPNOTSUPP;
1617                 }
1618
1619                 r = install_info_add_auto(&c, *i);
1620                 if (r < 0)
1621                         return r;
1622         }
1623
1624         /* This will return the number of symlink rules that were
1625         supposed to be created, not the ones actually created. This is
1626         useful to determine whether the passed files had any
1627         installation data at all. */
1628
1629         return install_context_apply(&c, &paths, config_path, root_dir, force, changes, n_changes);
1630 }
1631
1632 int unit_file_disable(
1633                 UnitFileScope scope,
1634                 bool runtime,
1635                 const char *root_dir,
1636                 char **files,
1637                 UnitFileChange **changes,
1638                 unsigned *n_changes) {
1639
1640         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1641         _cleanup_(install_context_done) InstallContext c = {};
1642         char **i;
1643         _cleanup_free_ char *config_path = NULL;
1644         _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
1645         int r, q;
1646
1647         assert(scope >= 0);
1648         assert(scope < _UNIT_FILE_SCOPE_MAX);
1649
1650         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1651         if (r < 0)
1652                 return r;
1653
1654         r = get_config_path(scope, runtime, root_dir, &config_path);
1655         if (r < 0)
1656                 return r;
1657
1658         STRV_FOREACH(i, files) {
1659                 r = install_info_add_auto(&c, *i);
1660                 if (r < 0)
1661                         return r;
1662         }
1663
1664         r = install_context_mark_for_removal(&c, &paths, &remove_symlinks_to, config_path, root_dir);
1665
1666         q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
1667         if (r >= 0)
1668                 r = q;
1669
1670         return r;
1671 }
1672
1673 int unit_file_reenable(
1674                 UnitFileScope scope,
1675                 bool runtime,
1676                 const char *root_dir,
1677                 char **files,
1678                 bool force,
1679                 UnitFileChange **changes,
1680                 unsigned *n_changes) {
1681         int r;
1682
1683         r = unit_file_disable(scope, runtime, root_dir, files,
1684                               changes, n_changes);
1685         if (r < 0)
1686                 return r;
1687
1688         return unit_file_enable(scope, runtime, root_dir, files, force,
1689                                 changes, n_changes);
1690 }
1691
1692 int unit_file_set_default(
1693                 UnitFileScope scope,
1694                 const char *root_dir,
1695                 const char *file,
1696                 bool force,
1697                 UnitFileChange **changes,
1698                 unsigned *n_changes) {
1699
1700         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1701         _cleanup_(install_context_done) InstallContext c = {};
1702         _cleanup_free_ char *config_path = NULL;
1703         char *path;
1704         int r;
1705         InstallInfo *i = NULL;
1706
1707         assert(scope >= 0);
1708         assert(scope < _UNIT_FILE_SCOPE_MAX);
1709         assert(file);
1710
1711         if (unit_name_to_type(file) != UNIT_TARGET)
1712                 return -EINVAL;
1713
1714         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1715         if (r < 0)
1716                 return r;
1717
1718         r = get_config_path(scope, false, root_dir, &config_path);
1719         if (r < 0)
1720                 return r;
1721
1722         r = install_info_add_auto(&c, file);
1723         if (r < 0)
1724                 return r;
1725
1726         assert_se(i = ordered_hashmap_first(c.will_install));
1727
1728         r = unit_file_search(&c, i, &paths, root_dir, false, true, NULL);
1729         if (r < 0)
1730                 return r;
1731
1732         path = strjoina(config_path, "/" SPECIAL_DEFAULT_TARGET);
1733
1734         r = create_symlink(i->path, path, force, changes, n_changes);
1735         if (r < 0)
1736                 return r;
1737
1738         return 0;
1739 }
1740
1741 int unit_file_get_default(
1742                 UnitFileScope scope,
1743                 const char *root_dir,
1744                 char **name) {
1745
1746         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1747         char **p;
1748         int r;
1749
1750         assert(scope >= 0);
1751         assert(scope < _UNIT_FILE_SCOPE_MAX);
1752         assert(name);
1753
1754         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1755         if (r < 0)
1756                 return r;
1757
1758         STRV_FOREACH(p, paths.unit_path) {
1759                 _cleanup_free_ char *path = NULL, *tmp = NULL;
1760                 char *n;
1761
1762                 path = path_join(root_dir, *p, SPECIAL_DEFAULT_TARGET);
1763                 if (!path)
1764                         return -ENOMEM;
1765
1766                 r = readlink_malloc(path, &tmp);
1767                 if (r == -ENOENT)
1768                         continue;
1769                 else if (r == -EINVAL)
1770                         /* not a symlink */
1771                         n = strdup(SPECIAL_DEFAULT_TARGET);
1772                 else if (r < 0)
1773                         return r;
1774                 else
1775                         n = strdup(basename(tmp));
1776
1777                 if (!n)
1778                         return -ENOMEM;
1779
1780                 *name = n;
1781                 return 0;
1782         }
1783
1784         return -ENOENT;
1785 }
1786
1787 UnitFileState unit_file_get_state(
1788                 UnitFileScope scope,
1789                 const char *root_dir,
1790                 const char *name) {
1791
1792         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1793         UnitFileState state = _UNIT_FILE_STATE_INVALID;
1794         char **i;
1795         _cleanup_free_ char *path = NULL;
1796         int r;
1797
1798         assert(scope >= 0);
1799         assert(scope < _UNIT_FILE_SCOPE_MAX);
1800         assert(name);
1801
1802         if (root_dir && scope != UNIT_FILE_SYSTEM)
1803                 return -EINVAL;
1804
1805         if (!unit_name_is_valid(name, TEMPLATE_VALID))
1806                 return -EINVAL;
1807
1808         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1809         if (r < 0)
1810                 return r;
1811
1812         STRV_FOREACH(i, paths.unit_path) {
1813                 struct stat st;
1814                 char *partial;
1815                 bool also = false;
1816
1817                 free(path);
1818                 path = NULL;
1819
1820                 path = path_join(root_dir, *i, name);
1821                 if (!path)
1822                         return -ENOMEM;
1823
1824                 if (root_dir)
1825                         partial = path + strlen(root_dir);
1826                 else
1827                         partial = path;
1828
1829                 /*
1830                  * Search for a unit file in our default paths, to
1831                  * be sure, that there are no broken symlinks.
1832                  */
1833                 if (lstat(path, &st) < 0) {
1834                         r = -errno;
1835                         if (errno != ENOENT)
1836                                 return r;
1837
1838                         if (!unit_name_is_instance(name))
1839                                 continue;
1840                 } else {
1841                         if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode))
1842                                 return -ENOENT;
1843
1844                         r = null_or_empty_path(path);
1845                         if (r < 0 && r != -ENOENT)
1846                                 return r;
1847                         else if (r > 0) {
1848                                 state = path_startswith(*i, "/run") ?
1849                                         UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
1850                                 return state;
1851                         }
1852                 }
1853
1854                 r = find_symlinks_in_scope(scope, root_dir, name, &state);
1855                 if (r < 0)
1856                         return r;
1857                 else if (r > 0)
1858                         return state;
1859
1860                 r = unit_file_can_install(&paths, root_dir, partial, true, &also);
1861                 if (r < 0 && errno != ENOENT)
1862                         return r;
1863                 else if (r > 0)
1864                         return UNIT_FILE_DISABLED;
1865                 else if (r == 0) {
1866                         if (also)
1867                                 return UNIT_FILE_INDIRECT;
1868                         return UNIT_FILE_STATIC;
1869                 }
1870         }
1871
1872         return r < 0 ? r : state;
1873 }
1874
1875 int unit_file_query_preset(UnitFileScope scope, const char *root_dir, const char *name) {
1876         _cleanup_strv_free_ char **files = NULL;
1877         char **p;
1878         int r;
1879
1880         assert(scope >= 0);
1881         assert(scope < _UNIT_FILE_SCOPE_MAX);
1882         assert(name);
1883
1884         if (scope == UNIT_FILE_SYSTEM)
1885                 r = conf_files_list(&files, ".preset", root_dir,
1886                                     "/etc/systemd/system-preset",
1887                                     "/usr/local/lib/systemd/system-preset",
1888                                     "/usr/lib/systemd/system-preset",
1889 #ifdef HAVE_SPLIT_USR
1890                                     "/lib/systemd/system-preset",
1891 #endif
1892                                     NULL);
1893         else if (scope == UNIT_FILE_GLOBAL)
1894                 r = conf_files_list(&files, ".preset", root_dir,
1895                                     "/etc/systemd/user-preset",
1896                                     "/usr/local/lib/systemd/user-preset",
1897                                     "/usr/lib/systemd/user-preset",
1898                                     NULL);
1899         else
1900                 return 1;
1901
1902         if (r < 0)
1903                 return r;
1904
1905         STRV_FOREACH(p, files) {
1906                 _cleanup_fclose_ FILE *f;
1907
1908                 f = fopen(*p, "re");
1909                 if (!f) {
1910                         if (errno == ENOENT)
1911                                 continue;
1912
1913                         return -errno;
1914                 }
1915
1916                 for (;;) {
1917                         char line[LINE_MAX], *l;
1918
1919                         if (!fgets(line, sizeof(line), f))
1920                                 break;
1921
1922                         l = strstrip(line);
1923                         if (!*l)
1924                                 continue;
1925
1926                         if (strchr(COMMENTS "\n", *l))
1927                                 continue;
1928
1929                         if (first_word(l, "enable")) {
1930                                 l += 6;
1931                                 l += strspn(l, WHITESPACE);
1932
1933                                 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1934                                         log_debug("Preset file says enable %s.", name);
1935                                         return 1;
1936                                 }
1937
1938                         } else if (first_word(l, "disable")) {
1939                                 l += 7;
1940                                 l += strspn(l, WHITESPACE);
1941
1942                                 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1943                                         log_debug("Preset file says disable %s.", name);
1944                                         return 0;
1945                                 }
1946
1947                         } else
1948                                 log_debug("Couldn't parse line '%s'", l);
1949                 }
1950         }
1951
1952         /* Default is "enable" */
1953         log_debug("Preset file doesn't say anything about %s, enabling.", name);
1954         return 1;
1955 }
1956
1957 int unit_file_preset(
1958                 UnitFileScope scope,
1959                 bool runtime,
1960                 const char *root_dir,
1961                 char **files,
1962                 UnitFilePresetMode mode,
1963                 bool force,
1964                 UnitFileChange **changes,
1965                 unsigned *n_changes) {
1966
1967         _cleanup_(install_context_done) InstallContext plus = {}, minus = {};
1968         _cleanup_lookup_paths_free_ LookupPaths paths = {};
1969         _cleanup_free_ char *config_path = NULL;
1970         char **i;
1971         int r, q;
1972
1973         assert(scope >= 0);
1974         assert(scope < _UNIT_FILE_SCOPE_MAX);
1975         assert(mode < _UNIT_FILE_PRESET_MAX);
1976
1977         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1978         if (r < 0)
1979                 return r;
1980
1981         r = get_config_path(scope, runtime, root_dir, &config_path);
1982         if (r < 0)
1983                 return r;
1984
1985         STRV_FOREACH(i, files) {
1986
1987                 if (!unit_name_is_valid(*i, TEMPLATE_VALID))
1988                         return -EINVAL;
1989
1990                 r = unit_file_query_preset(scope, root_dir, *i);
1991                 if (r < 0)
1992                         return r;
1993
1994                 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
1995                         r = install_info_add_auto(&plus, *i);
1996                 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
1997                         r = install_info_add_auto(&minus, *i);
1998                 else
1999                         r = 0;
2000                 if (r < 0)
2001                         return r;
2002         }
2003
2004         r = 0;
2005
2006         if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2007                 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2008
2009                 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2010
2011                 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
2012                 if (r == 0)
2013                         r = q;
2014         }
2015
2016         if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2017                 /* Returns number of symlinks that where supposed to be installed. */
2018                 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2019                 if (r == 0)
2020                         r = q;
2021         }
2022
2023         return r;
2024 }
2025
2026 int unit_file_preset_all(
2027                 UnitFileScope scope,
2028                 bool runtime,
2029                 const char *root_dir,
2030                 UnitFilePresetMode mode,
2031                 bool force,
2032                 UnitFileChange **changes,
2033                 unsigned *n_changes) {
2034
2035         _cleanup_(install_context_done) InstallContext plus = {}, minus = {};
2036         _cleanup_lookup_paths_free_ LookupPaths paths = {};
2037         _cleanup_free_ char *config_path = NULL;
2038         char **i;
2039         int r, q;
2040
2041         assert(scope >= 0);
2042         assert(scope < _UNIT_FILE_SCOPE_MAX);
2043         assert(mode < _UNIT_FILE_PRESET_MAX);
2044
2045         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2046         if (r < 0)
2047                 return r;
2048
2049         r = get_config_path(scope, runtime, root_dir, &config_path);
2050         if (r < 0)
2051                 return r;
2052
2053         STRV_FOREACH(i, paths.unit_path) {
2054                 _cleanup_closedir_ DIR *d = NULL;
2055                 _cleanup_free_ char *units_dir;
2056
2057                 units_dir = path_join(root_dir, *i, NULL);
2058                 if (!units_dir)
2059                         return -ENOMEM;
2060
2061                 d = opendir(units_dir);
2062                 if (!d) {
2063                         if (errno == ENOENT)
2064                                 continue;
2065
2066                         return -errno;
2067                 }
2068
2069                 for (;;) {
2070                         struct dirent *de;
2071
2072                         errno = 0;
2073                         de = readdir(d);
2074                         if (!de && errno != 0)
2075                                 return -errno;
2076
2077                         if (!de)
2078                                 break;
2079
2080                         if (hidden_file(de->d_name))
2081                                 continue;
2082
2083                         if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2084                                 continue;
2085
2086                         dirent_ensure_type(d, de);
2087
2088                         if (de->d_type != DT_REG)
2089                                 continue;
2090
2091                         r = unit_file_query_preset(scope, root_dir, de->d_name);
2092                         if (r < 0)
2093                                 return r;
2094
2095                         if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
2096                                 r = install_info_add_auto(&plus, de->d_name);
2097                         else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
2098                                 r = install_info_add_auto(&minus, de->d_name);
2099                         else
2100                                 r = 0;
2101                         if (r < 0)
2102                                 return r;
2103                 }
2104         }
2105
2106         r = 0;
2107
2108         if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2109                 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2110
2111                 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2112
2113                 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, NULL);
2114                 if (r == 0)
2115                         r = q;
2116         }
2117
2118         if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2119                 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2120                 if (r == 0)
2121                         r = q;
2122         }
2123
2124         return r;
2125 }
2126
2127 static void unit_file_list_free_one(UnitFileList *f) {
2128         if (!f)
2129                 return;
2130
2131         free(f->path);
2132         free(f);
2133 }
2134
2135 DEFINE_TRIVIAL_CLEANUP_FUNC(UnitFileList*, unit_file_list_free_one);
2136
2137 int unit_file_get_list(
2138                 UnitFileScope scope,
2139                 const char *root_dir,
2140                 Hashmap *h) {
2141
2142         _cleanup_lookup_paths_free_ LookupPaths paths = {};
2143         char **i;
2144         int r;
2145
2146         assert(scope >= 0);
2147         assert(scope < _UNIT_FILE_SCOPE_MAX);
2148         assert(h);
2149
2150         if (root_dir && scope != UNIT_FILE_SYSTEM)
2151                 return -EINVAL;
2152
2153         if (root_dir) {
2154                 r = access(root_dir, F_OK);
2155                 if (r < 0)
2156                         return -errno;
2157         }
2158
2159         r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2160         if (r < 0)
2161                 return r;
2162
2163         STRV_FOREACH(i, paths.unit_path) {
2164                 _cleanup_closedir_ DIR *d = NULL;
2165                 _cleanup_free_ char *units_dir;
2166
2167                 units_dir = path_join(root_dir, *i, NULL);
2168                 if (!units_dir)
2169                         return -ENOMEM;
2170
2171                 d = opendir(units_dir);
2172                 if (!d) {
2173                         if (errno == ENOENT)
2174                                 continue;
2175
2176                         return -errno;
2177                 }
2178
2179                 for (;;) {
2180                         _cleanup_(unit_file_list_free_onep) UnitFileList *f = NULL;
2181                         struct dirent *de;
2182                         _cleanup_free_ char *path = NULL;
2183
2184                         errno = 0;
2185                         de = readdir(d);
2186                         if (!de && errno != 0)
2187                                 return -errno;
2188
2189                         if (!de)
2190                                 break;
2191
2192                         if (hidden_file(de->d_name))
2193                                 continue;
2194
2195                         if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2196                                 continue;
2197
2198                         if (hashmap_get(h, de->d_name))
2199                                 continue;
2200
2201                         dirent_ensure_type(d, de);
2202
2203                         if (!IN_SET(de->d_type, DT_LNK, DT_REG))
2204                                 continue;
2205
2206                         f = new0(UnitFileList, 1);
2207                         if (!f)
2208                                 return -ENOMEM;
2209
2210                         f->path = path_make_absolute(de->d_name, units_dir);
2211                         if (!f->path)
2212                                 return -ENOMEM;
2213
2214                         r = null_or_empty_path(f->path);
2215                         if (r < 0 && r != -ENOENT)
2216                                 return r;
2217                         else if (r > 0) {
2218                                 f->state =
2219                                         path_startswith(*i, "/run") ?
2220                                         UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
2221                                 goto found;
2222                         }
2223
2224                         r = find_symlinks_in_scope(scope, root_dir, de->d_name, &f->state);
2225                         if (r < 0)
2226                                 return r;
2227                         else if (r > 0) {
2228                                 f->state = UNIT_FILE_ENABLED;
2229                                 goto found;
2230                         }
2231
2232                         path = path_make_absolute(de->d_name, *i);
2233                         if (!path)
2234                                 return -ENOMEM;
2235
2236                         r = unit_file_can_install(&paths, root_dir, path, true, NULL);
2237                         if (r == -EINVAL ||  /* Invalid setting? */
2238                             r == -EBADMSG || /* Invalid format? */
2239                             r == -ENOENT     /* Included file not found? */)
2240                                 f->state = UNIT_FILE_INVALID;
2241                         else if (r < 0)
2242                                 return r;
2243                         else if (r > 0)
2244                                 f->state = UNIT_FILE_DISABLED;
2245                         else
2246                                 f->state = UNIT_FILE_STATIC;
2247
2248                 found:
2249                         r = hashmap_put(h, basename(f->path), f);
2250                         if (r < 0)
2251                                 return r;
2252                         f = NULL; /* prevent cleanup */
2253                 }
2254         }
2255
2256         return r;
2257 }
2258
2259 static const char* const unit_file_state_table[_UNIT_FILE_STATE_MAX] = {
2260         [UNIT_FILE_ENABLED] = "enabled",
2261         [UNIT_FILE_ENABLED_RUNTIME] = "enabled-runtime",
2262         [UNIT_FILE_LINKED] = "linked",
2263         [UNIT_FILE_LINKED_RUNTIME] = "linked-runtime",
2264         [UNIT_FILE_MASKED] = "masked",
2265         [UNIT_FILE_MASKED_RUNTIME] = "masked-runtime",
2266         [UNIT_FILE_STATIC] = "static",
2267         [UNIT_FILE_DISABLED] = "disabled",
2268         [UNIT_FILE_INDIRECT] = "indirect",
2269         [UNIT_FILE_INVALID] = "invalid",
2270 };
2271
2272 DEFINE_STRING_TABLE_LOOKUP(unit_file_state, UnitFileState);
2273
2274 static const char* const unit_file_change_type_table[_UNIT_FILE_CHANGE_TYPE_MAX] = {
2275         [UNIT_FILE_SYMLINK] = "symlink",
2276         [UNIT_FILE_UNLINK] = "unlink",
2277 };
2278
2279 DEFINE_STRING_TABLE_LOOKUP(unit_file_change_type, UnitFileChangeType);
2280
2281 static const char* const unit_file_preset_mode_table[_UNIT_FILE_PRESET_MAX] = {
2282         [UNIT_FILE_PRESET_FULL] = "full",
2283         [UNIT_FILE_PRESET_ENABLE_ONLY] = "enable-only",
2284         [UNIT_FILE_PRESET_DISABLE_ONLY] = "disable-only",
2285 };
2286
2287 DEFINE_STRING_TABLE_LOOKUP(unit_file_preset_mode, UnitFilePresetMode);