src/libsystemd/sd-path/sd-path.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <stdlib.h>
   4
   5 #include "sd-path.h"
   6
   7 #include "alloc-util.h"
   8 #include "architecture.h"
   9 #include "fd-util.h"
  10 #include "fileio.h"
  11 #include "fs-util.h"
  12 #include "network-util.h"
  13 #include "nulstr-util.h"
  14 #include "path-lookup.h"
  15 #include "path-util.h"
  16 #include "string-util.h"
  17 #include "strv.h"
  18 #include "user-util.h"
  19
  20 static int from_environment(const char *envname, const char *fallback, const char **ret) {
  21         assert(ret);
  22
  23         if (envname) {
  24                 const char *e;
  25
  26                 e = secure_getenv(envname);
  27                 if (e && path_is_absolute(e)) {
  28                         *ret = e;
  29                         return 0;
  30                 }
  31         }
  32
  33         if (fallback) {
  34                 *ret = fallback;
  35                 return 0;
  36         }
  37
  38         return -ENXIO;
  39 }
  40
  41 static int from_home_dir(
  42                 const char *envname,
  43                 const char *suffix,
  44                 char **buffer,
  45                 const char **ret) {
  46
  47         _cleanup_free_ char *h = NULL;
  48         int r;
  49
  50         assert(suffix);
  51         assert(buffer);
  52         assert(ret);
  53
  54         if (envname) {
  55                 const char *e = NULL;
  56
  57                 e = secure_getenv(envname);
  58                 if (e && path_is_absolute(e)) {
  59                         *ret = e;
  60                         return 0;
  61                 }
  62         }
  63
  64         r = get_home_dir(&h);
  65         if (r < 0)
  66                 return r;
  67
  68         if (!path_extend(&h, suffix))
  69                 return -ENOMEM;
  70
  71         *buffer = h;
  72         *ret = TAKE_PTR(h);
  73         return 0;
  74 }
  75
  76 static int from_xdg_user_dir(const char *field, char **buffer, const char **ret) {
  77         _cleanup_free_ char *user_dirs = NULL;
  78         _cleanup_fclose_ FILE *f = NULL;
  79         int r;
  80
  81         assert(field);
  82         assert(buffer);
  83         assert(ret);
  84
  85         r = sd_path_lookup(SD_PATH_USER_CONFIGURATION, "user-dirs.dirs", &user_dirs);
  86         if (r < 0)
  87                 return r;
  88
  89         f = fopen(user_dirs, "re");
  90         if (!f) {
  91                 if (errno == ENOENT)
  92                         goto fallback;
  93
  94                 return -errno;
  95         }
  96
  97         /* This is an awful parse, but it follows closely what xdg-user-dirs does upstream */
  98         for (;;) {
  99                 _cleanup_free_ char *line = NULL;
 100                 char *p, *e;
 101
 102                 r = read_stripped_line(f, LONG_LINE_MAX, &line);
 103                 if (r < 0)
 104                         return r;
 105                 if (r == 0)
 106                         break;
 107
 108                 p = startswith(line, field);
 109                 if (!p)
 110                         continue;
 111
 112                 p = skip_leading_chars(p, WHITESPACE);
 113                 if (*p != '=')
 114                         continue;
 115                 p++;
 116
 117                 p = skip_leading_chars(p, WHITESPACE);
 118                 if (*p != '"')
 119                         continue;
 120                 p++;
 121
 122                 e = strrchr(p, '"');
 123                 if (!e)
 124                         continue;
 125                 *e = 0;
 126
 127                 /* Three syntaxes permitted: relative to $HOME, $HOME itself, and absolute path */
 128                 if (streq(p, "$HOME"))
 129                         goto home;
 130
 131                 const char *s = startswith(p, "$HOME/");
 132                 if (s)
 133                         return from_home_dir(/* envname = */ NULL, s, buffer, ret);
 134
 135                 if (path_is_absolute(p)) {
 136                         char *c = strdup(p);
 137                         if (!c)
 138                                 return -ENOMEM;
 139
 140                         *ret = *buffer = c;
 141                         return 0;
 142                 }
 143         }
 144
 145 fallback:
 146         /* The desktop directory defaults to $HOME/Desktop, the others to $HOME */
 147         if (streq(field, "XDG_DESKTOP_DIR"))
 148                 return from_home_dir(/* envname = */ NULL, "Desktop", buffer, ret);
 149
 150 home:
 151         r = get_home_dir(buffer);
 152         if (r < 0)
 153                 return r;
 154
 155         *ret = *buffer;
 156         return 0;
 157 }
 158
 159 static int get_path(uint64_t type, char **buffer, const char **ret) {
 160         int r;
 161
 162         assert(buffer);
 163         assert(ret);
 164
 165         switch (type) {
 166
 167         case SD_PATH_TEMPORARY:
 168                 return tmp_dir(ret);
 169
 170         case SD_PATH_TEMPORARY_LARGE:
 171                 return var_tmp_dir(ret);
 172
 173         case SD_PATH_SYSTEM_BINARIES:
 174                 *ret = "/usr/bin";
 175                 return 0;
 176
 177         case SD_PATH_SYSTEM_INCLUDE:
 178                 *ret = "/usr/include";
 179                 return 0;
 180
 181         case SD_PATH_SYSTEM_LIBRARY_PRIVATE:
 182                 *ret = "/usr/lib";
 183                 return 0;
 184
 185         case SD_PATH_SYSTEM_LIBRARY_ARCH:
 186                 *ret = LIBDIR;
 187                 return 0;
 188
 189         case SD_PATH_SYSTEM_SHARED:
 190                 *ret = "/usr/share";
 191                 return 0;
 192
 193         case SD_PATH_SYSTEM_CONFIGURATION_FACTORY:
 194                 *ret = "/usr/share/factory/etc";
 195                 return 0;
 196
 197         case SD_PATH_SYSTEM_STATE_FACTORY:
 198                 *ret = "/usr/share/factory/var";
 199                 return 0;
 200
 201         case SD_PATH_SYSTEM_CONFIGURATION:
 202                 *ret = "/etc";
 203                 return 0;
 204
 205         case SD_PATH_SYSTEM_RUNTIME:
 206                 *ret = "/run";
 207                 return 0;
 208
 209         case SD_PATH_SYSTEM_RUNTIME_LOGS:
 210                 *ret = "/run/log";
 211                 return 0;
 212
 213         case SD_PATH_SYSTEM_STATE_PRIVATE:
 214                 *ret = "/var/lib";
 215                 return 0;
 216
 217         case SD_PATH_SYSTEM_STATE_LOGS:
 218                 *ret = "/var/log";
 219                 return 0;
 220
 221         case SD_PATH_SYSTEM_STATE_CACHE:
 222                 *ret = "/var/cache";
 223                 return 0;
 224
 225         case SD_PATH_SYSTEM_STATE_SPOOL:
 226                 *ret = "/var/spool";
 227                 return 0;
 228
 229         case SD_PATH_USER_BINARIES:
 230                 return from_home_dir(NULL, ".local/bin", buffer, ret);
 231
 232         case SD_PATH_USER_LIBRARY_PRIVATE:
 233                 return from_home_dir(NULL, ".local/lib", buffer, ret);
 234
 235         case SD_PATH_USER_LIBRARY_ARCH:
 236                 return from_home_dir(NULL, ".local/lib/" LIB_ARCH_TUPLE, buffer, ret);
 237
 238         case SD_PATH_USER_SHARED:
 239                 return from_home_dir("XDG_DATA_HOME", ".local/share", buffer, ret);
 240
 241         case SD_PATH_USER_CONFIGURATION:
 242                 return from_home_dir("XDG_CONFIG_HOME", ".config", buffer, ret);
 243
 244         case SD_PATH_USER_RUNTIME:
 245                 return from_environment("XDG_RUNTIME_DIR", NULL, ret);
 246
 247         case SD_PATH_USER_STATE_CACHE:
 248                 return from_home_dir("XDG_CACHE_HOME", ".cache", buffer, ret);
 249
 250         case SD_PATH_USER_STATE_PRIVATE:
 251                 return from_home_dir("XDG_STATE_HOME", ".local/state", buffer, ret);
 252
 253         case SD_PATH_USER:
 254                 r = get_home_dir(buffer);
 255                 if (r < 0)
 256                         return r;
 257
 258                 *ret = *buffer;
 259                 return 0;
 260
 261         case SD_PATH_USER_DOCUMENTS:
 262                 return from_xdg_user_dir("XDG_DOCUMENTS_DIR", buffer, ret);
 263
 264         case SD_PATH_USER_MUSIC:
 265                 return from_xdg_user_dir("XDG_MUSIC_DIR", buffer, ret);
 266
 267         case SD_PATH_USER_PICTURES:
 268                 return from_xdg_user_dir("XDG_PICTURES_DIR", buffer, ret);
 269
 270         case SD_PATH_USER_VIDEOS:
 271                 return from_xdg_user_dir("XDG_VIDEOS_DIR", buffer, ret);
 272
 273         case SD_PATH_USER_DOWNLOAD:
 274                 return from_xdg_user_dir("XDG_DOWNLOAD_DIR", buffer, ret);
 275
 276         case SD_PATH_USER_PUBLIC:
 277                 return from_xdg_user_dir("XDG_PUBLICSHARE_DIR", buffer, ret);
 278
 279         case SD_PATH_USER_TEMPLATES:
 280                 return from_xdg_user_dir("XDG_TEMPLATES_DIR", buffer, ret);
 281
 282         case SD_PATH_USER_DESKTOP:
 283                 return from_xdg_user_dir("XDG_DESKTOP_DIR", buffer, ret);
 284
 285         case SD_PATH_SYSTEMD_UTIL:
 286                 *ret = PREFIX_NOSLASH "/lib/systemd";
 287                 return 0;
 288
 289         case SD_PATH_SYSTEMD_SYSTEM_UNIT:
 290                 *ret = SYSTEM_DATA_UNIT_DIR;
 291                 return 0;
 292
 293         case SD_PATH_SYSTEMD_SYSTEM_PRESET:
 294                 *ret = PREFIX_NOSLASH "/lib/systemd/system-preset";
 295                 return 0;
 296
 297         case SD_PATH_SYSTEMD_USER_UNIT:
 298                 *ret = USER_DATA_UNIT_DIR;
 299                 return 0;
 300
 301         case SD_PATH_SYSTEMD_USER_PRESET:
 302                 *ret = PREFIX_NOSLASH "/lib/systemd/user-preset";
 303                 return 0;
 304
 305         case SD_PATH_SYSTEMD_INITRD_PRESET:
 306                 *ret = PREFIX_NOSLASH "/lib/systemd/initrd-preset";
 307                 return 0;
 308
 309         case SD_PATH_SYSTEMD_SYSTEM_CONF:
 310                 *ret = SYSTEM_CONFIG_UNIT_DIR;
 311                 return 0;
 312
 313         case SD_PATH_SYSTEMD_USER_CONF:
 314                 *ret = USER_CONFIG_UNIT_DIR;
 315                 return 0;
 316
 317         case SD_PATH_SYSTEMD_SYSTEM_GENERATOR:
 318                 *ret = SYSTEM_GENERATOR_DIR;
 319                 return 0;
 320
 321         case SD_PATH_SYSTEMD_USER_GENERATOR:
 322                 *ret = USER_GENERATOR_DIR;
 323                 return 0;
 324
 325         case SD_PATH_SYSTEMD_SLEEP:
 326                 *ret = PREFIX_NOSLASH "/lib/systemd/system-sleep";
 327                 return 0;
 328
 329         case SD_PATH_SYSTEMD_SHUTDOWN:
 330                 *ret = PREFIX_NOSLASH "/lib/systemd/system-shutdown";
 331                 return 0;
 332
 333         case SD_PATH_TMPFILES:
 334                 *ret = "/usr/lib/tmpfiles.d";
 335                 return 0;
 336
 337         case SD_PATH_SYSUSERS:
 338                 *ret = PREFIX_NOSLASH "/lib/sysusers.d";
 339                 return 0;
 340
 341         case SD_PATH_SYSCTL:
 342                 *ret = PREFIX_NOSLASH "/lib/sysctl.d";
 343                 return 0;
 344
 345         case SD_PATH_BINFMT:
 346                 *ret = PREFIX_NOSLASH "/lib/binfmt.d";
 347                 return 0;
 348
 349         case SD_PATH_MODULES_LOAD:
 350                 *ret = PREFIX_NOSLASH "/lib/modules-load.d";
 351                 return 0;
 352
 353         case SD_PATH_CATALOG:
 354                 *ret = "/usr/lib/systemd/catalog";
 355                 return 0;
 356
 357         case SD_PATH_SYSTEMD_SYSTEM_ENVIRONMENT_GENERATOR:
 358                 *ret = SYSTEM_ENV_GENERATOR_DIR;
 359                 return 0;
 360
 361         case SD_PATH_SYSTEMD_USER_ENVIRONMENT_GENERATOR:
 362                 *ret = USER_ENV_GENERATOR_DIR;
 363                 return 0;
 364
 365         case SD_PATH_SYSTEM_CREDENTIAL_STORE:
 366                 *ret = "/etc/credstore";
 367                 return 0;
 368
 369         case SD_PATH_SYSTEM_CREDENTIAL_STORE_ENCRYPTED:
 370                 *ret = "/etc/credstore.encrypted";
 371                 return 0;
 372
 373         case SD_PATH_USER_CREDENTIAL_STORE:
 374                 r = xdg_user_config_dir("credstore", buffer);
 375                 if (r < 0)
 376                         return r;
 377
 378                 *ret = *buffer;
 379                 return 0;
 380
 381         case SD_PATH_USER_CREDENTIAL_STORE_ENCRYPTED:
 382                 r = xdg_user_config_dir("credstore.encrypted", buffer);
 383                 if (r < 0)
 384                         return r;
 385
 386                 *ret = *buffer;
 387                 return 0;
 388         }
 389
 390         return -EOPNOTSUPP;
 391 }
 392
 393 static int get_path_alloc(uint64_t type, const char *suffix, char **ret) {
 394         _cleanup_free_ char *buffer = NULL;
 395         const char *p;
 396         int r;
 397
 398         assert(ret);
 399
 400         r = get_path(type, &buffer, &p);
 401         if (r < 0)
 402                 return r;
 403
 404         if (!isempty(suffix)) {
 405                 char *suffixed = path_join(p, suffix);
 406                 if (!suffixed)
 407                         return -ENOMEM;
 408
 409                 path_simplify_full(suffixed, PATH_SIMPLIFY_KEEP_TRAILING_SLASH);
 410
 411                 free_and_replace(buffer, suffixed);
 412         } else if (!buffer) {
 413                 buffer = strdup(p);
 414                 if (!buffer)
 415                         return -ENOMEM;
 416         }
 417
 418         *ret = TAKE_PTR(buffer);
 419         return 0;
 420 }
 421
 422 _public_ int sd_path_lookup(uint64_t type, const char *suffix, char **ret) {
 423         int r;
 424
 425         assert_return(ret, -EINVAL);
 426
 427         r = get_path_alloc(type, suffix, ret);
 428         if (r != -EOPNOTSUPP)
 429                 return r;
 430
 431         /* Fall back to sd_path_lookup_strv */
 432         _cleanup_strv_free_ char **l = NULL;
 433
 434         r = sd_path_lookup_strv(type, suffix, &l);
 435         if (r < 0)
 436                 return r;
 437
 438         char *joined = strv_join(l, ":");
 439         if (!joined)
 440                 return -ENOMEM;
 441
 442         *ret = joined;
 443         return 0;
 444 }
 445
 446 static int search_from_environment(
 447                 char ***ret,
 448                 const char *env_home,
 449                 const char *home_suffix,
 450                 const char *env_search,
 451                 bool env_search_sufficient,
 452                 const char *first, ...) {
 453
 454         _cleanup_strv_free_ char **l = NULL;
 455         const char *e;
 456         char *h = NULL;
 457         int r;
 458
 459         assert(ret);
 460
 461         if (env_search) {
 462                 e = secure_getenv(env_search);
 463                 if (e) {
 464                         l = strv_split(e, ":");
 465                         if (!l)
 466                                 return -ENOMEM;
 467
 468                         if (env_search_sufficient) {
 469                                 *ret = TAKE_PTR(l);
 470                                 return 0;
 471                         }
 472                 }
 473         }
 474
 475         if (!l && first) {
 476                 va_list ap;
 477
 478                 va_start(ap, first);
 479                 l = strv_new_ap(first, ap);
 480                 va_end(ap);
 481
 482                 if (!l)
 483                         return -ENOMEM;
 484         }
 485
 486         if (env_home) {
 487                 e = secure_getenv(env_home);
 488                 if (e && path_is_absolute(e)) {
 489                         h = strdup(e);
 490                         if (!h)
 491                                 return -ENOMEM;
 492                 }
 493         }
 494
 495         if (!h && home_suffix) {
 496                 e = secure_getenv("HOME");
 497                 if (e && path_is_absolute(e)) {
 498                         h = path_join(e, home_suffix);
 499                         if (!h)
 500                                 return -ENOMEM;
 501                 }
 502         }
 503
 504         if (h) {
 505                 r = strv_consume_prepend(&l, h);
 506                 if (r < 0)
 507                         return -ENOMEM;
 508         }
 509
 510         *ret = TAKE_PTR(l);
 511         return 0;
 512 }
 513
 514 #if HAVE_SPLIT_BIN
 515 #  define ARRAY_SBIN_BIN(x) x "sbin", x "bin"
 516 #else
 517 #  define ARRAY_SBIN_BIN(x) x "bin"
 518 #endif
 519
 520 static int get_search(uint64_t type, char ***ret) {
 521         int r;
 522
 523         assert(ret);
 524
 525         switch (type) {
 526
 527         case SD_PATH_SEARCH_BINARIES:
 528                 return search_from_environment(ret,
 529                                                NULL,
 530                                                ".local/bin",
 531                                                "PATH",
 532                                                true,
 533                                                ARRAY_SBIN_BIN("/usr/local/"),
 534                                                ARRAY_SBIN_BIN("/usr/"),
 535                                                NULL);
 536
 537         case SD_PATH_SEARCH_LIBRARY_PRIVATE:
 538                 return search_from_environment(ret,
 539                                                NULL,
 540                                                ".local/lib",
 541                                                NULL,
 542                                                false,
 543                                                "/usr/local/lib",
 544                                                "/usr/lib",
 545                                                NULL);
 546
 547         case SD_PATH_SEARCH_LIBRARY_ARCH:
 548                 return search_from_environment(ret,
 549                                                NULL,
 550                                                ".local/lib/" LIB_ARCH_TUPLE,
 551                                                "LD_LIBRARY_PATH",
 552                                                true,
 553                                                LIBDIR,
 554                                                NULL);
 555
 556         case SD_PATH_SEARCH_SHARED:
 557                 return search_from_environment(ret,
 558                                                "XDG_DATA_HOME",
 559                                                ".local/share",
 560                                                "XDG_DATA_DIRS",
 561                                                false,
 562                                                "/usr/local/share",
 563                                                "/usr/share",
 564                                                NULL);
 565
 566         case SD_PATH_SEARCH_CONFIGURATION_FACTORY:
 567                 return search_from_environment(ret,
 568                                                NULL,
 569                                                NULL,
 570                                                NULL,
 571                                                false,
 572                                                "/usr/local/share/factory/etc",
 573                                                "/usr/share/factory/etc",
 574                                                NULL);
 575
 576         case SD_PATH_SEARCH_STATE_FACTORY:
 577                 return search_from_environment(ret,
 578                                                NULL,
 579                                                NULL,
 580                                                NULL,
 581                                                false,
 582                                                "/usr/local/share/factory/var",
 583                                                "/usr/share/factory/var",
 584                                                NULL);
 585
 586         case SD_PATH_SEARCH_CONFIGURATION:
 587                 return search_from_environment(ret,
 588                                                "XDG_CONFIG_HOME",
 589                                                ".config",
 590                                                "XDG_CONFIG_DIRS",
 591                                                false,
 592                                                "/etc",
 593                                                NULL);
 594
 595         case SD_PATH_SEARCH_BINARIES_DEFAULT: {
 596                 char **t = strv_split(default_PATH(), ":");
 597                 if (!t)
 598                         return -ENOMEM;
 599
 600                 *ret = t;
 601                 return 0;
 602         }
 603
 604         case SD_PATH_SYSTEMD_SEARCH_SYSTEM_UNIT:
 605         case SD_PATH_SYSTEMD_SEARCH_USER_UNIT: {
 606                 _cleanup_(lookup_paths_done) LookupPaths lp = {};
 607                 RuntimeScope scope = type == SD_PATH_SYSTEMD_SEARCH_SYSTEM_UNIT ?
 608                         RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER;
 609
 610                 r = lookup_paths_init(&lp, scope, 0, NULL);
 611                 if (r < 0)
 612                         return r;
 613
 614                 *ret = TAKE_PTR(lp.search_path);
 615                 return 0;
 616         }
 617
 618         case SD_PATH_SYSTEMD_SEARCH_SYSTEM_GENERATOR:
 619         case SD_PATH_SYSTEMD_SEARCH_USER_GENERATOR:
 620         case SD_PATH_SYSTEMD_SEARCH_SYSTEM_ENVIRONMENT_GENERATOR:
 621         case SD_PATH_SYSTEMD_SEARCH_USER_ENVIRONMENT_GENERATOR: {
 622                 RuntimeScope scope = IN_SET(type, SD_PATH_SYSTEMD_SEARCH_SYSTEM_GENERATOR,
 623                                                   SD_PATH_SYSTEMD_SEARCH_SYSTEM_ENVIRONMENT_GENERATOR) ?
 624                                      RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER;
 625                 bool env_generator = IN_SET(type, SD_PATH_SYSTEMD_SEARCH_SYSTEM_ENVIRONMENT_GENERATOR,
 626                                                   SD_PATH_SYSTEMD_SEARCH_USER_ENVIRONMENT_GENERATOR);
 627
 628                 char **t = generator_binary_paths_internal(scope, env_generator);
 629                 if (!t)
 630                         return -ENOMEM;
 631
 632                 *ret = t;
 633                 return 0;
 634         }
 635
 636         case SD_PATH_SYSTEMD_SEARCH_NETWORK:
 637                 return strv_from_nulstr(ret, NETWORK_DIRS_NULSTR);
 638
 639         case SD_PATH_SYSTEM_SEARCH_CREDENTIAL_STORE:
 640         case SD_PATH_SYSTEM_SEARCH_CREDENTIAL_STORE_ENCRYPTED: {
 641                 const char *suffix =
 642                         type == SD_PATH_SYSTEM_SEARCH_CREDENTIAL_STORE_ENCRYPTED ? "credstore.encrypted" : "credstore";
 643
 644                 _cleanup_strv_free_ char **l = NULL;
 645                 FOREACH_STRING(d, CONF_PATHS("")) {
 646                         char *j = path_join(d, suffix);
 647                         if (!j)
 648                                 return -ENOMEM;
 649
 650                         r = strv_consume(&l, TAKE_PTR(j));
 651                         if (r < 0)
 652                                 return r;
 653                 }
 654
 655                 *ret = TAKE_PTR(l);
 656                 return 0;
 657         }
 658
 659         case SD_PATH_USER_SEARCH_CREDENTIAL_STORE:
 660         case SD_PATH_USER_SEARCH_CREDENTIAL_STORE_ENCRYPTED: {
 661                 const char *suffix =
 662                         type == SD_PATH_USER_SEARCH_CREDENTIAL_STORE_ENCRYPTED ? "credstore.encrypted" : "credstore";
 663
 664                 static const uint64_t dirs[] = {
 665                         SD_PATH_USER_CONFIGURATION,
 666                         SD_PATH_USER_RUNTIME,
 667                         SD_PATH_USER_LIBRARY_PRIVATE,
 668                 };
 669
 670                 _cleanup_strv_free_ char **l = NULL;
 671                 FOREACH_ELEMENT(d, dirs) {
 672                         _cleanup_free_ char *p = NULL;
 673                         r = sd_path_lookup(*d, suffix, &p);
 674                         if (r == -ENXIO)
 675                                 continue;
 676                         if (r < 0)
 677                                 return r;
 678
 679                         r = strv_consume(&l, TAKE_PTR(p));
 680                         if (r < 0)
 681                                 return r;
 682                 }
 683
 684                 *ret = TAKE_PTR(l);
 685                 return 0;
 686         }}
 687
 688         return -EOPNOTSUPP;
 689 }
 690
 691 _public_ int sd_path_lookup_strv(uint64_t type, const char *suffix, char ***ret) {
 692         _cleanup_strv_free_ char **l = NULL;
 693         int r;
 694
 695         assert_return(ret, -EINVAL);
 696
 697         r = get_search(type, &l);
 698         if (r == -EOPNOTSUPP) {
 699                 _cleanup_free_ char *t = NULL;
 700
 701                 r = get_path_alloc(type, suffix, &t);
 702                 if (r < 0)
 703                         return r;
 704
 705                 l = new(char*, 2);
 706                 if (!l)
 707                         return -ENOMEM;
 708                 l[0] = TAKE_PTR(t);
 709                 l[1] = NULL;
 710
 711                 *ret = TAKE_PTR(l);
 712                 return 0;
 713         }
 714         if (r < 0)
 715                 return r;
 716
 717         if (suffix)
 718                 STRV_FOREACH(i, l) {
 719                         if (!path_extend(i, suffix))
 720                                 return -ENOMEM;
 721
 722                         path_simplify_full(*i, PATH_SIMPLIFY_KEEP_TRAILING_SLASH);
 723                 }
 724
 725         *ret = TAKE_PTR(l);
 726         return 0;
 727 }