src/sysv-generator/sysv-generator.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2014 Thomas H.P. Andersen
   4   Copyright © 2011 Michal Schmidt
   5 ***/
   6
   7 #include <errno.h>
   8 #include <stdio.h>
   9 #include <unistd.h>
  10
  11 #include "alloc-util.h"
  12 #include "dirent-util.h"
  13 #include "exit-status.h"
  14 #include "fd-util.h"
  15 #include "fileio.h"
  16 #include "generator.h"
  17 #include "hashmap.h"
  18 #include "hexdecoct.h"
  19 #include "install.h"
  20 #include "log.h"
  21 #include "mkdir.h"
  22 #include "path-lookup.h"
  23 #include "path-util.h"
  24 #include "set.h"
  25 #include "special.h"
  26 #include "specifier.h"
  27 #include "stat-util.h"
  28 #include "string-util.h"
  29 #include "strv.h"
  30 #include "unit-name.h"
  31 #include "util.h"
  32
  33 static const struct {
  34         const char *path;
  35         const char *target;
  36 } rcnd_table[] = {
  37         /* Standard SysV runlevels for start-up */
  38         { "rc1.d",  SPECIAL_RESCUE_TARGET     },
  39         { "rc2.d",  SPECIAL_MULTI_USER_TARGET },
  40         { "rc3.d",  SPECIAL_MULTI_USER_TARGET },
  41         { "rc4.d",  SPECIAL_MULTI_USER_TARGET },
  42         { "rc5.d",  SPECIAL_GRAPHICAL_TARGET  },
  43
  44         /* We ignore the SysV runlevels for shutdown here, as SysV services get default dependencies anyway, and that
  45          * means they are shut down anyway at system power off if running. */
  46 };
  47
  48 static const char *arg_dest = "/tmp";
  49
  50 typedef struct SysvStub {
  51         char *name;
  52         char *path;
  53         char *description;
  54         int sysv_start_priority;
  55         char *pid_file;
  56         char **before;
  57         char **after;
  58         char **wants;
  59         char **wanted_by;
  60         bool has_lsb;
  61         bool reload;
  62         bool loaded;
  63 } SysvStub;
  64
  65 static void free_sysvstub(SysvStub *s) {
  66         if (!s)
  67                 return;
  68
  69         free(s->name);
  70         free(s->path);
  71         free(s->description);
  72         free(s->pid_file);
  73         strv_free(s->before);
  74         strv_free(s->after);
  75         strv_free(s->wants);
  76         strv_free(s->wanted_by);
  77         free(s);
  78 }
  79
  80 DEFINE_TRIVIAL_CLEANUP_FUNC(SysvStub*, free_sysvstub);
  81
  82 static void free_sysvstub_hashmapp(Hashmap **h) {
  83         hashmap_free_with_destructor(*h, free_sysvstub);
  84 }
  85
  86 static int add_alias(const char *service, const char *alias) {
  87         const char *link;
  88         int r;
  89
  90         assert(service);
  91         assert(alias);
  92
  93         link = strjoina(arg_dest, "/", alias);
  94
  95         r = symlink(service, link);
  96         if (r < 0) {
  97                 if (errno == EEXIST)
  98                         return 0;
  99
 100                 return -errno;
 101         }
 102
 103         return 1;
 104 }
 105
 106 static int generate_unit_file(SysvStub *s) {
 107         _cleanup_free_ char *path_escaped = NULL;
 108         _cleanup_fclose_ FILE *f = NULL;
 109         const char *unit;
 110         char **p;
 111         int r;
 112
 113         assert(s);
 114
 115         if (!s->loaded)
 116                 return 0;
 117
 118         path_escaped = specifier_escape(s->path);
 119         if (!path_escaped)
 120                 return log_oom();
 121
 122         unit = strjoina(arg_dest, "/", s->name);
 123
 124         /* We might already have a symlink with the same name from a Provides:,
 125          * or from backup files like /etc/init.d/foo.bak. Real scripts always win,
 126          * so remove an existing link */
 127         if (is_symlink(unit) > 0) {
 128                 log_warning("Overwriting existing symlink %s with real service.", unit);
 129                 (void) unlink(unit);
 130         }
 131
 132         f = fopen(unit, "wxe");
 133         if (!f)
 134                 return log_error_errno(errno, "Failed to create unit file %s: %m", unit);
 135
 136         fprintf(f,
 137                 "# Automatically generated by systemd-sysv-generator\n\n"
 138                 "[Unit]\n"
 139                 "Documentation=man:systemd-sysv-generator(8)\n"
 140                 "SourcePath=%s\n",
 141                 path_escaped);
 142
 143         if (s->description) {
 144                 _cleanup_free_ char *t;
 145
 146                 t = specifier_escape(s->description);
 147                 if (!t)
 148                         return log_oom();
 149
 150                 fprintf(f, "Description=%s\n", t);
 151         }
 152
 153         STRV_FOREACH(p, s->before)
 154                 fprintf(f, "Before=%s\n", *p);
 155         STRV_FOREACH(p, s->after)
 156                 fprintf(f, "After=%s\n", *p);
 157         STRV_FOREACH(p, s->wants)
 158                 fprintf(f, "Wants=%s\n", *p);
 159
 160         fprintf(f,
 161                 "\n[Service]\n"
 162                 "Type=forking\n"
 163                 "Restart=no\n"
 164                 "TimeoutSec=5min\n"
 165                 "IgnoreSIGPIPE=no\n"
 166                 "KillMode=process\n"
 167                 "GuessMainPID=no\n"
 168                 "RemainAfterExit=%s\n",
 169                 yes_no(!s->pid_file));
 170
 171         if (s->pid_file) {
 172                 _cleanup_free_ char *t;
 173
 174                 t = specifier_escape(s->pid_file);
 175                 if (!t)
 176                         return log_oom();
 177
 178                 fprintf(f, "PIDFile=%s\n", t);
 179         }
 180
 181         /* Consider two special LSB exit codes a clean exit */
 182         if (s->has_lsb)
 183                 fprintf(f,
 184                         "SuccessExitStatus=%i %i\n",
 185                         EXIT_NOTINSTALLED,
 186                         EXIT_NOTCONFIGURED);
 187
 188         fprintf(f,
 189                 "ExecStart=%s start\n"
 190                 "ExecStop=%s stop\n",
 191                 path_escaped, path_escaped);
 192
 193         if (s->reload)
 194                 fprintf(f, "ExecReload=%s reload\n", path_escaped);
 195
 196         r = fflush_and_check(f);
 197         if (r < 0)
 198                 return log_error_errno(r, "Failed to write unit %s: %m", unit);
 199
 200         STRV_FOREACH(p, s->wanted_by)
 201                 (void) generator_add_symlink(arg_dest, *p, "wants", s->name);
 202
 203         return 1;
 204 }
 205
 206 static bool usage_contains_reload(const char *line) {
 207         return (strcasestr(line, "{reload|") ||
 208                 strcasestr(line, "{reload}") ||
 209                 strcasestr(line, "{reload\"") ||
 210                 strcasestr(line, "|reload|") ||
 211                 strcasestr(line, "|reload}") ||
 212                 strcasestr(line, "|reload\""));
 213 }
 214
 215 static char *sysv_translate_name(const char *name) {
 216         _cleanup_free_ char *c = NULL;
 217         char *res;
 218
 219         c = strdup(name);
 220         if (!c)
 221                 return NULL;
 222
 223         res = endswith(c, ".sh");
 224         if (res)
 225                 *res = 0;
 226
 227         if (unit_name_mangle(c, 0, &res) < 0)
 228                 return NULL;
 229
 230         return res;
 231 }
 232
 233 static int sysv_translate_facility(SysvStub *s, unsigned line, const char *name, char **ret) {
 234
 235         /* We silently ignore the $ prefix here. According to the LSB
 236          * spec it simply indicates whether something is a
 237          * standardized name or a distribution-specific one. Since we
 238          * just follow what already exists and do not introduce new
 239          * uses or names we don't care who introduced a new name. */
 240
 241         static const char * const table[] = {
 242                 /* LSB defined facilities */
 243                 "local_fs",             NULL,
 244                 "network",              SPECIAL_NETWORK_ONLINE_TARGET,
 245                 "named",                SPECIAL_NSS_LOOKUP_TARGET,
 246                 "portmap",              SPECIAL_RPCBIND_TARGET,
 247                 "remote_fs",            SPECIAL_REMOTE_FS_TARGET,
 248                 "syslog",               NULL,
 249                 "time",                 SPECIAL_TIME_SYNC_TARGET,
 250         };
 251
 252         const char *filename;
 253         char *filename_no_sh, *e, *m;
 254         const char *n;
 255         unsigned i;
 256         int r;
 257
 258         assert(name);
 259         assert(s);
 260         assert(ret);
 261
 262         filename = basename(s->path);
 263
 264         n = *name == '$' ? name + 1 : name;
 265
 266         for (i = 0; i < ELEMENTSOF(table); i += 2) {
 267                 if (!streq(table[i], n))
 268                         continue;
 269
 270                 if (!table[i+1]) {
 271                         *ret = NULL;
 272                         return 0;
 273                 }
 274
 275                 m = strdup(table[i+1]);
 276                 if (!m)
 277                         return log_oom();
 278
 279                 *ret = m;
 280                 return 1;
 281         }
 282
 283         /* If we don't know this name, fallback heuristics to figure
 284          * out whether something is a target or a service alias. */
 285
 286         /* Facilities starting with $ are most likely targets */
 287         if (*name == '$')  {
 288                 r = unit_name_build(n, NULL, ".target", ret);
 289                 if (r < 0)
 290                         return log_error_errno(r, "[%s:%u] Could not build name for facility %s: %m", s->path, line, name);
 291
 292                 return 1;
 293         }
 294
 295         /* Strip ".sh" suffix from file name for comparison */
 296         filename_no_sh = strdupa(filename);
 297         e = endswith(filename_no_sh, ".sh");
 298         if (e) {
 299                 *e = '\0';
 300                 filename = filename_no_sh;
 301         }
 302
 303         /* Names equaling the file name of the services are redundant */
 304         if (streq_ptr(n, filename)) {
 305                 *ret = NULL;
 306                 return 0;
 307         }
 308
 309         /* Everything else we assume to be normal service names */
 310         m = sysv_translate_name(n);
 311         if (!m)
 312                 return log_oom();
 313
 314         *ret = m;
 315         return 1;
 316 }
 317
 318 static int handle_provides(SysvStub *s, unsigned line, const char *full_text, const char *text) {
 319         int r;
 320
 321         assert(s);
 322         assert(full_text);
 323         assert(text);
 324
 325         for (;;) {
 326                 _cleanup_free_ char *word = NULL, *m = NULL;
 327
 328                 r = extract_first_word(&text, &word, NULL, EXTRACT_QUOTES|EXTRACT_RELAX);
 329                 if (r < 0)
 330                         return log_error_errno(r, "[%s:%u] Failed to parse word from provides string: %m", s->path, line);
 331                 if (r == 0)
 332                         break;
 333
 334                 r = sysv_translate_facility(s, line, word, &m);
 335                 if (r <= 0) /* continue on error */
 336                         continue;
 337
 338                 switch (unit_name_to_type(m)) {
 339
 340                 case UNIT_SERVICE:
 341                         log_debug("Adding Provides: alias '%s' for '%s'", m, s->name);
 342                         r = add_alias(s->name, m);
 343                         if (r < 0)
 344                                 log_warning_errno(r, "[%s:%u] Failed to add LSB Provides name %s, ignoring: %m", s->path, line, m);
 345                         break;
 346
 347                 case UNIT_TARGET:
 348
 349                         /* NB: SysV targets which are provided by a
 350                          * service are pulled in by the services, as
 351                          * an indication that the generic service is
 352                          * now available. This is strictly one-way.
 353                          * The targets do NOT pull in SysV services! */
 354
 355                         r = strv_extend(&s->before, m);
 356                         if (r < 0)
 357                                 return log_oom();
 358
 359                         r = strv_extend(&s->wants, m);
 360                         if (r < 0)
 361                                 return log_oom();
 362
 363                         if (streq(m, SPECIAL_NETWORK_ONLINE_TARGET)) {
 364                                 r = strv_extend(&s->before, SPECIAL_NETWORK_TARGET);
 365                                 if (r < 0)
 366                                         return log_oom();
 367                                 r = strv_extend(&s->wants, SPECIAL_NETWORK_TARGET);
 368                                 if (r < 0)
 369                                         return log_oom();
 370                         }
 371
 372                         break;
 373
 374                 case _UNIT_TYPE_INVALID:
 375                         log_warning("Unit name '%s' is invalid", m);
 376                         break;
 377
 378                 default:
 379                         log_warning("Unknown unit type for unit '%s'", m);
 380                 }
 381         }
 382
 383         return 0;
 384 }
 385
 386 static int handle_dependencies(SysvStub *s, unsigned line, const char *full_text, const char *text) {
 387         int r;
 388
 389         assert(s);
 390         assert(full_text);
 391         assert(text);
 392
 393         for (;;) {
 394                 _cleanup_free_ char *word = NULL, *m = NULL;
 395                 bool is_before;
 396
 397                 r = extract_first_word(&text, &word, NULL, EXTRACT_QUOTES|EXTRACT_RELAX);
 398                 if (r < 0)
 399                         return log_error_errno(r, "[%s:%u] Failed to parse word from provides string: %m", s->path, line);
 400                 if (r == 0)
 401                         break;
 402
 403                 r = sysv_translate_facility(s, line, word, &m);
 404                 if (r <= 0) /* continue on error */
 405                         continue;
 406
 407                 is_before = startswith_no_case(full_text, "X-Start-Before:");
 408
 409                 if (streq(m, SPECIAL_NETWORK_ONLINE_TARGET) && !is_before) {
 410                         /* the network-online target is special, as it needs to be actively pulled in */
 411                         r = strv_extend(&s->after, m);
 412                         if (r < 0)
 413                                 return log_oom();
 414
 415                         r = strv_extend(&s->wants, m);
 416                 } else
 417                         r = strv_extend(is_before ? &s->before : &s->after, m);
 418                 if (r < 0)
 419                         return log_oom();
 420         }
 421
 422         return 0;
 423 }
 424
 425 static int load_sysv(SysvStub *s) {
 426         _cleanup_fclose_ FILE *f;
 427         unsigned line = 0;
 428         int r;
 429         enum {
 430                 NORMAL,
 431                 DESCRIPTION,
 432                 LSB,
 433                 LSB_DESCRIPTION,
 434                 USAGE_CONTINUATION
 435         } state = NORMAL;
 436         _cleanup_free_ char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL;
 437         char *description;
 438         bool supports_reload = false;
 439         char l[LINE_MAX];
 440
 441         assert(s);
 442
 443         f = fopen(s->path, "re");
 444         if (!f) {
 445                 if (errno == ENOENT)
 446                         return 0;
 447
 448                 return log_error_errno(errno, "Failed to open %s: %m", s->path);
 449         }
 450
 451         log_debug("Loading SysV script %s", s->path);
 452
 453         FOREACH_LINE(l, f, goto fail) {
 454                 char *t;
 455
 456                 line++;
 457
 458                 t = strstrip(l);
 459                 if (*t != '#') {
 460                         /* Try to figure out whether this init script supports
 461                          * the reload operation. This heuristic looks for
 462                          * "Usage" lines which include the reload option. */
 463                         if ( state == USAGE_CONTINUATION ||
 464                             (state == NORMAL && strcasestr(t, "usage"))) {
 465                                 if (usage_contains_reload(t)) {
 466                                         supports_reload = true;
 467                                         state = NORMAL;
 468                                 } else if (t[strlen(t)-1] == '\\')
 469                                         state = USAGE_CONTINUATION;
 470                                 else
 471                                         state = NORMAL;
 472                         }
 473
 474                         continue;
 475                 }
 476
 477                 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
 478                         state = LSB;
 479                         s->has_lsb = true;
 480                         continue;
 481                 }
 482
 483                 if (IN_SET(state, LSB_DESCRIPTION, LSB) && streq(t, "### END INIT INFO")) {
 484                         state = NORMAL;
 485                         continue;
 486                 }
 487
 488                 t++;
 489                 t += strspn(t, WHITESPACE);
 490
 491                 if (state == NORMAL) {
 492
 493                         /* Try to parse Red Hat style description */
 494
 495                         if (startswith_no_case(t, "description:")) {
 496
 497                                 size_t k;
 498                                 const char *j;
 499
 500                                 k = strlen(t);
 501                                 if (k > 0 && t[k-1] == '\\') {
 502                                         state = DESCRIPTION;
 503                                         t[k-1] = 0;
 504                                 }
 505
 506                                 j = empty_to_null(strstrip(t+12));
 507
 508                                 r = free_and_strdup(&chkconfig_description, j);
 509                                 if (r < 0)
 510                                         return log_oom();
 511
 512                         } else if (startswith_no_case(t, "pidfile:")) {
 513                                 const char *fn;
 514
 515                                 state = NORMAL;
 516
 517                                 fn = strstrip(t+8);
 518                                 if (!path_is_absolute(fn)) {
 519                                         log_error("[%s:%u] PID file not absolute. Ignoring.", s->path, line);
 520                                         continue;
 521                                 }
 522
 523                                 r = free_and_strdup(&s->pid_file, fn);
 524                                 if (r < 0)
 525                                         return log_oom();
 526                         }
 527
 528                 } else if (state == DESCRIPTION) {
 529
 530                         /* Try to parse Red Hat style description
 531                          * continuation */
 532
 533                         size_t k;
 534                         char *j;
 535
 536                         k = strlen(t);
 537                         if (k > 0 && t[k-1] == '\\')
 538                                 t[k-1] = 0;
 539                         else
 540                                 state = NORMAL;
 541
 542                         j = strstrip(t);
 543                         if (!isempty(j)) {
 544                                 char *d = NULL;
 545
 546                                 if (chkconfig_description)
 547                                         d = strjoin(chkconfig_description, " ", j);
 548                                 else
 549                                         d = strdup(j);
 550                                 if (!d)
 551                                         return log_oom();
 552
 553                                 free(chkconfig_description);
 554                                 chkconfig_description = d;
 555                         }
 556
 557                 } else if (IN_SET(state, LSB, LSB_DESCRIPTION)) {
 558
 559                         if (startswith_no_case(t, "Provides:")) {
 560                                 state = LSB;
 561
 562                                 r = handle_provides(s, line, t, t + 9);
 563                                 if (r < 0)
 564                                         return r;
 565
 566                         } else if (startswith_no_case(t, "Required-Start:") ||
 567                                    startswith_no_case(t, "Should-Start:") ||
 568                                    startswith_no_case(t, "X-Start-Before:") ||
 569                                    startswith_no_case(t, "X-Start-After:")) {
 570
 571                                 state = LSB;
 572
 573                                 r = handle_dependencies(s, line, t, strchr(t, ':') + 1);
 574                                 if (r < 0)
 575                                         return r;
 576
 577                         } else if (startswith_no_case(t, "Description:")) {
 578                                 const char *j;
 579
 580                                 state = LSB_DESCRIPTION;
 581
 582                                 j = empty_to_null(strstrip(t+12));
 583
 584                                 r = free_and_strdup(&long_description, j);
 585                                 if (r < 0)
 586                                         return log_oom();
 587
 588                         } else if (startswith_no_case(t, "Short-Description:")) {
 589                                 const char *j;
 590
 591                                 state = LSB;
 592
 593                                 j = empty_to_null(strstrip(t+18));
 594
 595                                 r = free_and_strdup(&short_description, j);
 596                                 if (r < 0)
 597                                         return log_oom();
 598
 599                         } else if (state == LSB_DESCRIPTION) {
 600
 601                                 if (startswith(l, "#\t") || startswith(l, "#  ")) {
 602                                         const char *j;
 603
 604                                         j = strstrip(t);
 605                                         if (!isempty(j)) {
 606                                                 char *d = NULL;
 607
 608                                                 if (long_description)
 609                                                         d = strjoin(long_description, " ", t);
 610                                                 else
 611                                                         d = strdup(j);
 612                                                 if (!d)
 613                                                         return log_oom();
 614
 615                                                 free(long_description);
 616                                                 long_description = d;
 617                                         }
 618
 619                                 } else
 620                                         state = LSB;
 621                         }
 622                 }
 623         }
 624
 625         s->reload = supports_reload;
 626
 627         /* We use the long description only if
 628          * no short description is set. */
 629
 630         if (short_description)
 631                 description = short_description;
 632         else if (chkconfig_description)
 633                 description = chkconfig_description;
 634         else if (long_description)
 635                 description = long_description;
 636         else
 637                 description = NULL;
 638
 639         if (description) {
 640                 char *d;
 641
 642                 d = strappend(s->has_lsb ? "LSB: " : "SYSV: ", description);
 643                 if (!d)
 644                         return log_oom();
 645
 646                 s->description = d;
 647         }
 648
 649         s->loaded = true;
 650         return 0;
 651
 652 fail:
 653         return log_error_errno(errno, "Failed to read configuration file '%s': %m", s->path);
 654 }
 655
 656 static int fix_order(SysvStub *s, Hashmap *all_services) {
 657         SysvStub *other;
 658         Iterator j;
 659         int r;
 660
 661         assert(s);
 662
 663         if (!s->loaded)
 664                 return 0;
 665
 666         if (s->sysv_start_priority < 0)
 667                 return 0;
 668
 669         HASHMAP_FOREACH(other, all_services, j) {
 670                 if (s == other)
 671                         continue;
 672
 673                 if (!other->loaded)
 674                         continue;
 675
 676                 if (other->sysv_start_priority < 0)
 677                         continue;
 678
 679                 /* If both units have modern headers we don't care
 680                  * about the priorities */
 681                 if (s->has_lsb && other->has_lsb)
 682                         continue;
 683
 684                 if (other->sysv_start_priority < s->sysv_start_priority) {
 685                         r = strv_extend(&s->after, other->name);
 686                         if (r < 0)
 687                                 return log_oom();
 688
 689                 } else if (other->sysv_start_priority > s->sysv_start_priority) {
 690                         r = strv_extend(&s->before, other->name);
 691                         if (r < 0)
 692                                 return log_oom();
 693                 } else
 694                         continue;
 695
 696                 /* FIXME: Maybe we should compare the name here lexicographically? */
 697         }
 698
 699         return 0;
 700 }
 701
 702 static int acquire_search_path(const char *def, const char *envvar, char ***ret) {
 703         _cleanup_strv_free_ char **l = NULL;
 704         const char *e;
 705         int r;
 706
 707         assert(def);
 708         assert(envvar);
 709
 710         e = getenv(envvar);
 711         if (e) {
 712                 r = path_split_and_make_absolute(e, &l);
 713                 if (r < 0)
 714                         return log_error_errno(r, "Failed to make $%s search path absolute: %m", envvar);
 715         }
 716
 717         if (strv_isempty(l)) {
 718                 strv_free(l);
 719
 720                 l = strv_new(def, NULL);
 721                 if (!l)
 722                         return log_oom();
 723         }
 724
 725         if (!path_strv_resolve_uniq(l, NULL))
 726                 return log_oom();
 727
 728         *ret = TAKE_PTR(l);
 729
 730         return 0;
 731 }
 732
 733 static int enumerate_sysv(const LookupPaths *lp, Hashmap *all_services) {
 734         _cleanup_strv_free_ char **sysvinit_path = NULL;
 735         char **path;
 736         int r;
 737
 738         assert(lp);
 739
 740         r = acquire_search_path(SYSTEM_SYSVINIT_PATH, "SYSTEMD_SYSVINIT_PATH", &sysvinit_path);
 741         if (r < 0)
 742                 return r;
 743
 744         STRV_FOREACH(path, sysvinit_path) {
 745                 _cleanup_closedir_ DIR *d = NULL;
 746                 struct dirent *de;
 747
 748                 d = opendir(*path);
 749                 if (!d) {
 750                         if (errno != ENOENT)
 751                                 log_warning_errno(errno, "Opening %s failed, ignoring: %m", *path);
 752                         continue;
 753                 }
 754
 755                 FOREACH_DIRENT(de, d, log_error_errno(errno, "Failed to enumerate directory %s, ignoring: %m", *path)) {
 756                         _cleanup_free_ char *fpath = NULL, *name = NULL;
 757                         _cleanup_(free_sysvstubp) SysvStub *service = NULL;
 758                         struct stat st;
 759
 760                         if (fstatat(dirfd(d), de->d_name, &st, 0) < 0) {
 761                                 log_warning_errno(errno, "stat() failed on %s/%s, ignoring: %m", *path, de->d_name);
 762                                 continue;
 763                         }
 764
 765                         if (!(st.st_mode & S_IXUSR))
 766                                 continue;
 767
 768                         if (!S_ISREG(st.st_mode))
 769                                 continue;
 770
 771                         name = sysv_translate_name(de->d_name);
 772                         if (!name)
 773                                 return log_oom();
 774
 775                         if (hashmap_contains(all_services, name))
 776                                 continue;
 777
 778                         r = unit_file_exists(UNIT_FILE_SYSTEM, lp, name);
 779                         if (r < 0 && !IN_SET(r, -ELOOP, -ERFKILL, -EADDRNOTAVAIL)) {
 780                                 log_debug_errno(r, "Failed to detect whether %s exists, skipping: %m", name);
 781                                 continue;
 782                         } else if (r != 0) {
 783                                 log_debug("Native unit for %s already exists, skipping.", name);
 784                                 continue;
 785                         }
 786
 787                         fpath = strjoin(*path, "/", de->d_name);
 788                         if (!fpath)
 789                                 return log_oom();
 790
 791                         service = new0(SysvStub, 1);
 792                         if (!service)
 793                                 return log_oom();
 794
 795                         service->sysv_start_priority = -1;
 796                         service->name = TAKE_PTR(name);
 797                         service->path = TAKE_PTR(fpath);
 798
 799                         r = hashmap_put(all_services, service->name, service);
 800                         if (r < 0)
 801                                 return log_oom();
 802
 803                         service = NULL;
 804                 }
 805         }
 806
 807         return 0;
 808 }
 809
 810 static int set_dependencies_from_rcnd(const LookupPaths *lp, Hashmap *all_services) {
 811         Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
 812         _cleanup_strv_free_ char **sysvrcnd_path = NULL;
 813         SysvStub *service;
 814         unsigned i;
 815         Iterator j;
 816         char **p;
 817         int r;
 818
 819         assert(lp);
 820
 821         r = acquire_search_path(SYSTEM_SYSVRCND_PATH, "SYSTEMD_SYSVRCND_PATH", &sysvrcnd_path);
 822         if (r < 0)
 823                 return r;
 824
 825         STRV_FOREACH(p, sysvrcnd_path) {
 826                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
 827
 828                         _cleanup_closedir_ DIR *d = NULL;
 829                         _cleanup_free_ char *path = NULL;
 830                         struct dirent *de;
 831
 832                         path = strjoin(*p, "/", rcnd_table[i].path);
 833                         if (!path) {
 834                                 r = log_oom();
 835                                 goto finish;
 836                         }
 837
 838                         d = opendir(path);
 839                         if (!d) {
 840                                 if (errno != ENOENT)
 841                                         log_warning_errno(errno, "Opening %s failed, ignoring: %m", path);
 842
 843                                 continue;
 844                         }
 845
 846                         FOREACH_DIRENT(de, d, log_error_errno(errno, "Failed to enumerate directory %s, ignoring: %m", path)) {
 847                                 _cleanup_free_ char *name = NULL, *fpath = NULL;
 848                                 int a, b;
 849
 850                                 if (de->d_name[0] != 'S')
 851                                         continue;
 852
 853                                 if (strlen(de->d_name) < 4)
 854                                         continue;
 855
 856                                 a = undecchar(de->d_name[1]);
 857                                 b = undecchar(de->d_name[2]);
 858
 859                                 if (a < 0 || b < 0)
 860                                         continue;
 861
 862                                 fpath = strjoin(*p, "/", de->d_name);
 863                                 if (!fpath) {
 864                                         r = log_oom();
 865                                         goto finish;
 866                                 }
 867
 868                                 name = sysv_translate_name(de->d_name + 3);
 869                                 if (!name) {
 870                                         r = log_oom();
 871                                         goto finish;
 872                                 }
 873
 874                                 service = hashmap_get(all_services, name);
 875                                 if (!service) {
 876                                         log_debug("Ignoring %s symlink in %s, not generating %s.", de->d_name, rcnd_table[i].path, name);
 877                                         continue;
 878                                 }
 879
 880                                 service->sysv_start_priority = MAX(a*10 + b, service->sysv_start_priority);
 881
 882                                 r = set_ensure_allocated(&runlevel_services[i], NULL);
 883                                 if (r < 0) {
 884                                         log_oom();
 885                                         goto finish;
 886                                 }
 887
 888                                 r = set_put(runlevel_services[i], service);
 889                                 if (r < 0) {
 890                                         log_oom();
 891                                         goto finish;
 892                                 }
 893                         }
 894                 }
 895         }
 896
 897         for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
 898                 SET_FOREACH(service, runlevel_services[i], j) {
 899                         r = strv_extend(&service->before, rcnd_table[i].target);
 900                         if (r < 0) {
 901                                 log_oom();
 902                                 goto finish;
 903                         }
 904                         r = strv_extend(&service->wanted_by, rcnd_table[i].target);
 905                         if (r < 0) {
 906                                 log_oom();
 907                                 goto finish;
 908                         }
 909                 }
 910
 911         r = 0;
 912
 913 finish:
 914         for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
 915                 set_free(runlevel_services[i]);
 916
 917         return r;
 918 }
 919
 920 int main(int argc, char *argv[]) {
 921         _cleanup_(free_sysvstub_hashmapp) Hashmap *all_services = NULL;
 922         _cleanup_(lookup_paths_free) LookupPaths lp = {};
 923         SysvStub *service;
 924         Iterator j;
 925         int r;
 926
 927         if (argc > 1 && argc != 4) {
 928                 log_error("This program takes three or no arguments.");
 929                 return EXIT_FAILURE;
 930         }
 931
 932         if (argc > 1)
 933                 arg_dest = argv[3];
 934
 935         log_set_prohibit_ipc(true);
 936         log_set_target(LOG_TARGET_AUTO);
 937         log_parse_environment();
 938         log_open();
 939
 940         umask(0022);
 941
 942         r = lookup_paths_init(&lp, UNIT_FILE_SYSTEM, LOOKUP_PATHS_EXCLUDE_GENERATED, NULL);
 943         if (r < 0) {
 944                 log_error_errno(r, "Failed to find lookup paths: %m");
 945                 goto finish;
 946         }
 947
 948         all_services = hashmap_new(&string_hash_ops);
 949         if (!all_services) {
 950                 r = log_oom();
 951                 goto finish;
 952         }
 953
 954         r = enumerate_sysv(&lp, all_services);
 955         if (r < 0)
 956                 goto finish;
 957
 958         r = set_dependencies_from_rcnd(&lp, all_services);
 959         if (r < 0)
 960                 goto finish;
 961
 962         HASHMAP_FOREACH(service, all_services, j)
 963                 (void) load_sysv(service);
 964
 965         HASHMAP_FOREACH(service, all_services, j) {
 966                 (void) fix_order(service, all_services);
 967                 (void) generate_unit_file(service);
 968         }
 969
 970         r = 0;
 971
 972 finish:
 973         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 974 }