src/core/service.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 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 <signal.h>
  24 #include <dirent.h>
  25 #include <unistd.h>
  26 #include <sys/reboot.h>
  27
  28 #include "manager.h"
  29 #include "unit.h"
  30 #include "service.h"
  31 #include "load-fragment.h"
  32 #include "load-dropin.h"
  33 #include "log.h"
  34 #include "strv.h"
  35 #include "unit-name.h"
  36 #include "unit-printf.h"
  37 #include "dbus-service.h"
  38 #include "special.h"
  39 #include "bus-errors.h"
  40 #include "exit-status.h"
  41 #include "def.h"
  42 #include "path-util.h"
  43 #include "util.h"
  44 #include "utf8.h"
  45
  46 #ifdef HAVE_SYSV_COMPAT
  47
  48 #define DEFAULT_SYSV_TIMEOUT_USEC (5*USEC_PER_MINUTE)
  49
  50 typedef enum RunlevelType {
  51         RUNLEVEL_UP,
  52         RUNLEVEL_DOWN,
  53         RUNLEVEL_SYSINIT
  54 } RunlevelType;
  55
  56 static const struct {
  57         const char *path;
  58         const char *target;
  59         const RunlevelType type;
  60 } rcnd_table[] = {
  61         /* Standard SysV runlevels for start-up */
  62         { "rc1.d",  SPECIAL_RESCUE_TARGET,    RUNLEVEL_UP },
  63         { "rc2.d",  SPECIAL_RUNLEVEL2_TARGET, RUNLEVEL_UP },
  64         { "rc3.d",  SPECIAL_RUNLEVEL3_TARGET, RUNLEVEL_UP },
  65         { "rc4.d",  SPECIAL_RUNLEVEL4_TARGET, RUNLEVEL_UP },
  66         { "rc5.d",  SPECIAL_RUNLEVEL5_TARGET, RUNLEVEL_UP },
  67
  68 #ifdef TARGET_SUSE
  69         /* SUSE style boot.d */
  70         { "boot.d", SPECIAL_SYSINIT_TARGET,   RUNLEVEL_SYSINIT },
  71 #endif
  72
  73 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
  74         /* Debian style rcS.d */
  75         { "rcS.d",  SPECIAL_SYSINIT_TARGET,   RUNLEVEL_SYSINIT },
  76 #endif
  77
  78         /* Standard SysV runlevels for shutdown */
  79         { "rc0.d",  SPECIAL_POWEROFF_TARGET,  RUNLEVEL_DOWN },
  80         { "rc6.d",  SPECIAL_REBOOT_TARGET,    RUNLEVEL_DOWN }
  81
  82         /* Note that the order here matters, as we read the
  83            directories in this order, and we want to make sure that
  84            sysv_start_priority is known when we first load the
  85            unit. And that value we only know from S links. Hence
  86            UP/SYSINIT must be read before DOWN */
  87 };
  88
  89 #define RUNLEVELS_UP "12345"
  90 /* #define RUNLEVELS_DOWN "06" */
  91 #define RUNLEVELS_BOOT "bBsS"
  92 #endif
  93
  94 static const UnitActiveState state_translation_table[_SERVICE_STATE_MAX] = {
  95         [SERVICE_DEAD] = UNIT_INACTIVE,
  96         [SERVICE_START_PRE] = UNIT_ACTIVATING,
  97         [SERVICE_START] = UNIT_ACTIVATING,
  98         [SERVICE_START_POST] = UNIT_ACTIVATING,
  99         [SERVICE_RUNNING] = UNIT_ACTIVE,
 100         [SERVICE_EXITED] = UNIT_ACTIVE,
 101         [SERVICE_RELOAD] = UNIT_RELOADING,
 102         [SERVICE_STOP] = UNIT_DEACTIVATING,
 103         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
 104         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
 105         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
 106         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
 107         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
 108         [SERVICE_FAILED] = UNIT_FAILED,
 109         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
 110 };
 111
 112 /* For Type=idle we never want to delay any other jobs, hence we
 113  * consider idle jobs active as soon as we start working on them */
 114 static const UnitActiveState state_translation_table_idle[_SERVICE_STATE_MAX] = {
 115         [SERVICE_DEAD] = UNIT_INACTIVE,
 116         [SERVICE_START_PRE] = UNIT_ACTIVE,
 117         [SERVICE_START] = UNIT_ACTIVE,
 118         [SERVICE_START_POST] = UNIT_ACTIVE,
 119         [SERVICE_RUNNING] = UNIT_ACTIVE,
 120         [SERVICE_EXITED] = UNIT_ACTIVE,
 121         [SERVICE_RELOAD] = UNIT_RELOADING,
 122         [SERVICE_STOP] = UNIT_DEACTIVATING,
 123         [SERVICE_STOP_SIGTERM] = UNIT_DEACTIVATING,
 124         [SERVICE_STOP_SIGKILL] = UNIT_DEACTIVATING,
 125         [SERVICE_STOP_POST] = UNIT_DEACTIVATING,
 126         [SERVICE_FINAL_SIGTERM] = UNIT_DEACTIVATING,
 127         [SERVICE_FINAL_SIGKILL] = UNIT_DEACTIVATING,
 128         [SERVICE_FAILED] = UNIT_FAILED,
 129         [SERVICE_AUTO_RESTART] = UNIT_ACTIVATING
 130 };
 131
 132 static void service_init(Unit *u) {
 133         Service *s = SERVICE(u);
 134
 135         assert(u);
 136         assert(u->load_state == UNIT_STUB);
 137
 138         s->timeout_start_usec = DEFAULT_TIMEOUT_USEC;
 139         s->timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
 140         s->restart_usec = DEFAULT_RESTART_USEC;
 141         s->type = _SERVICE_TYPE_INVALID;
 142
 143         s->watchdog_watch.type = WATCH_INVALID;
 144
 145         s->timer_watch.type = WATCH_INVALID;
 146 #ifdef HAVE_SYSV_COMPAT
 147         s->sysv_start_priority = -1;
 148         s->sysv_start_priority_from_rcnd = -1;
 149 #endif
 150         s->socket_fd = -1;
 151         s->guess_main_pid = true;
 152
 153         exec_context_init(&s->exec_context);
 154         kill_context_init(&s->kill_context);
 155
 156         RATELIMIT_INIT(s->start_limit, 10*USEC_PER_SEC, 5);
 157
 158         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
 159 }
 160
 161 static void service_unwatch_control_pid(Service *s) {
 162         assert(s);
 163
 164         if (s->control_pid <= 0)
 165                 return;
 166
 167         unit_unwatch_pid(UNIT(s), s->control_pid);
 168         s->control_pid = 0;
 169 }
 170
 171 static void service_unwatch_main_pid(Service *s) {
 172         assert(s);
 173
 174         if (s->main_pid <= 0)
 175                 return;
 176
 177         unit_unwatch_pid(UNIT(s), s->main_pid);
 178         s->main_pid = 0;
 179 }
 180
 181 static void service_unwatch_pid_file(Service *s) {
 182         if (!s->pid_file_pathspec)
 183                 return;
 184
 185         log_debug("Stopping watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
 186         path_spec_unwatch(s->pid_file_pathspec, UNIT(s));
 187         path_spec_done(s->pid_file_pathspec);
 188         free(s->pid_file_pathspec);
 189         s->pid_file_pathspec = NULL;
 190 }
 191
 192 static int service_set_main_pid(Service *s, pid_t pid) {
 193         pid_t ppid;
 194
 195         assert(s);
 196
 197         if (pid <= 1)
 198                 return -EINVAL;
 199
 200         if (pid == getpid())
 201                 return -EINVAL;
 202
 203         s->main_pid = pid;
 204         s->main_pid_known = true;
 205
 206         if (get_parent_of_pid(pid, &ppid) >= 0 && ppid != getpid()) {
 207                 log_warning("%s: Supervising process %lu which is not our child. We'll most likely not notice when it exits.",
 208                             UNIT(s)->id, (unsigned long) pid);
 209
 210                 s->main_pid_alien = true;
 211         } else
 212                 s->main_pid_alien = false;
 213
 214         exec_status_start(&s->main_exec_status, pid);
 215
 216         return 0;
 217 }
 218
 219 static void service_close_socket_fd(Service *s) {
 220         assert(s);
 221
 222         if (s->socket_fd < 0)
 223                 return;
 224
 225         close_nointr_nofail(s->socket_fd);
 226         s->socket_fd = -1;
 227 }
 228
 229 static void service_connection_unref(Service *s) {
 230         assert(s);
 231
 232         if (!UNIT_DEREF(s->accept_socket))
 233                 return;
 234
 235         socket_connection_unref(SOCKET(UNIT_DEREF(s->accept_socket)));
 236         unit_ref_unset(&s->accept_socket);
 237 }
 238
 239 static void service_stop_watchdog(Service *s) {
 240         assert(s);
 241
 242         unit_unwatch_timer(UNIT(s), &s->watchdog_watch);
 243         s->watchdog_timestamp.realtime = 0;
 244         s->watchdog_timestamp.monotonic = 0;
 245 }
 246
 247 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart);
 248
 249 static void service_handle_watchdog(Service *s) {
 250         usec_t offset;
 251         int r;
 252
 253         assert(s);
 254
 255         if (s->watchdog_usec == 0)
 256                 return;
 257
 258         offset = now(CLOCK_MONOTONIC) - s->watchdog_timestamp.monotonic;
 259         if (offset >= s->watchdog_usec) {
 260                 log_error("%s watchdog timeout!", UNIT(s)->id);
 261                 service_enter_dead(s, SERVICE_FAILURE_WATCHDOG, true);
 262                 return;
 263         }
 264
 265         r = unit_watch_timer(UNIT(s), s->watchdog_usec - offset, &s->watchdog_watch);
 266         if (r < 0)
 267                 log_warning("%s failed to install watchdog timer: %s", UNIT(s)->id, strerror(-r));
 268 }
 269
 270 static void service_reset_watchdog(Service *s) {
 271         assert(s);
 272
 273         dual_timestamp_get(&s->watchdog_timestamp);
 274         service_handle_watchdog(s);
 275 }
 276
 277 static void service_done(Unit *u) {
 278         Service *s = SERVICE(u);
 279
 280         assert(s);
 281
 282         free(s->pid_file);
 283         s->pid_file = NULL;
 284
 285 #ifdef HAVE_SYSV_COMPAT
 286         free(s->sysv_runlevels);
 287         s->sysv_runlevels = NULL;
 288 #endif
 289
 290         free(s->status_text);
 291         s->status_text = NULL;
 292
 293         exec_context_done(&s->exec_context);
 294         exec_command_free_array(s->exec_command, _SERVICE_EXEC_COMMAND_MAX);
 295         s->control_command = NULL;
 296         s->main_command = NULL;
 297
 298         set_free(s->restart_ignore_status.code);
 299         s->restart_ignore_status.code = NULL;
 300         set_free(s->restart_ignore_status.signal);
 301         s->restart_ignore_status.signal = NULL;
 302
 303         set_free(s->success_status.code);
 304         s->success_status.code = NULL;
 305         set_free(s->success_status.signal);
 306         s->success_status.signal = NULL;
 307
 308         /* This will leak a process, but at least no memory or any of
 309          * our resources */
 310         service_unwatch_main_pid(s);
 311         service_unwatch_control_pid(s);
 312         service_unwatch_pid_file(s);
 313
 314         if (s->bus_name)  {
 315                 unit_unwatch_bus_name(u, s->bus_name);
 316                 free(s->bus_name);
 317                 s->bus_name = NULL;
 318         }
 319
 320         service_close_socket_fd(s);
 321         service_connection_unref(s);
 322
 323         unit_ref_unset(&s->accept_socket);
 324
 325         service_stop_watchdog(s);
 326
 327         unit_unwatch_timer(u, &s->timer_watch);
 328 }
 329
 330 #ifdef HAVE_SYSV_COMPAT
 331 static char *sysv_translate_name(const char *name) {
 332         char *r;
 333
 334         if (!(r = new(char, strlen(name) + sizeof(".service"))))
 335                 return NULL;
 336
 337 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
 338         if (endswith(name, ".sh"))
 339                 /* Drop Debian-style .sh suffix */
 340                 strcpy(stpcpy(r, name) - 3, ".service");
 341 #endif
 342 #ifdef TARGET_SUSE
 343         if (startswith(name, "boot."))
 344                 /* Drop SuSE-style boot. prefix */
 345                 strcpy(stpcpy(r, name + 5), ".service");
 346 #endif
 347 #ifdef TARGET_FRUGALWARE
 348         if (startswith(name, "rc."))
 349                 /* Drop Frugalware-style rc. prefix */
 350                 strcpy(stpcpy(r, name + 3), ".service");
 351 #endif
 352         else
 353                 /* Normal init scripts */
 354                 strcpy(stpcpy(r, name), ".service");
 355
 356         return r;
 357 }
 358
 359 static int sysv_translate_facility(const char *name, const char *filename, char **_r) {
 360
 361         /* We silently ignore the $ prefix here. According to the LSB
 362          * spec it simply indicates whether something is a
 363          * standardized name or a distribution-specific one. Since we
 364          * just follow what already exists and do not introduce new
 365          * uses or names we don't care who introduced a new name. */
 366
 367         static const char * const table[] = {
 368                 /* LSB defined facilities */
 369                 "local_fs",             SPECIAL_LOCAL_FS_TARGET,
 370 #if defined(TARGET_MANDRIVA) || defined(TARGET_MAGEIA)
 371 #else
 372                 /* Due to unfortunate name selection in Mandriva,
 373                  * $network is provided by network-up which is ordered
 374                  * after network which actually starts interfaces.
 375                  * To break the loop, just ignore it */
 376                 "network",              SPECIAL_NETWORK_TARGET,
 377 #endif
 378                 "named",                SPECIAL_NSS_LOOKUP_TARGET,
 379                 "portmap",              SPECIAL_RPCBIND_TARGET,
 380                 "remote_fs",            SPECIAL_REMOTE_FS_TARGET,
 381                 "syslog",               SPECIAL_SYSLOG_TARGET,
 382                 "time",                 SPECIAL_TIME_SYNC_TARGET,
 383
 384                 /* common extensions */
 385                 "mail-transfer-agent",  SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
 386                 "x-display-manager",    SPECIAL_DISPLAY_MANAGER_SERVICE,
 387                 "null",                 NULL,
 388
 389 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
 390                 "mail-transport-agent", SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
 391 #endif
 392
 393 #ifdef TARGET_FEDORA
 394                 "MTA",                  SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
 395                 "smtpdaemon",           SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
 396                 "httpd",                SPECIAL_HTTP_DAEMON_TARGET,
 397 #endif
 398
 399 #ifdef TARGET_SUSE
 400                 "smtp",                 SPECIAL_MAIL_TRANSFER_AGENT_TARGET,
 401 #endif
 402         };
 403
 404         unsigned i;
 405         char *r;
 406         const char *n;
 407
 408         assert(name);
 409         assert(_r);
 410
 411         n = *name == '$' ? name + 1 : name;
 412
 413         for (i = 0; i < ELEMENTSOF(table); i += 2) {
 414
 415                 if (!streq(table[i], n))
 416                         continue;
 417
 418                 if (!table[i+1])
 419                         return 0;
 420
 421                 if (!(r = strdup(table[i+1])))
 422                         return -ENOMEM;
 423
 424                 goto finish;
 425         }
 426
 427         /* If we don't know this name, fallback heuristics to figure
 428          * out whether something is a target or a service alias. */
 429
 430         if (*name == '$') {
 431                 if (!unit_prefix_is_valid(n))
 432                         return -EINVAL;
 433
 434                 /* Facilities starting with $ are most likely targets */
 435                 r = unit_name_build(n, NULL, ".target");
 436         } else if (filename && streq(name, filename))
 437                 /* Names equaling the file name of the services are redundant */
 438                 return 0;
 439         else
 440                 /* Everything else we assume to be normal service names */
 441                 r = sysv_translate_name(n);
 442
 443         if (!r)
 444                 return -ENOMEM;
 445
 446 finish:
 447         *_r = r;
 448
 449         return 1;
 450 }
 451
 452 static int sysv_fix_order(Service *s) {
 453         Unit *other;
 454         int r;
 455
 456         assert(s);
 457
 458         if (s->sysv_start_priority < 0)
 459                 return 0;
 460
 461         /* For each pair of services where at least one lacks a LSB
 462          * header, we use the start priority value to order things. */
 463
 464         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
 465                 Service *t;
 466                 UnitDependency d;
 467                 bool special_s, special_t;
 468
 469                 t = SERVICE(other);
 470
 471                 if (s == t)
 472                         continue;
 473
 474                 if (UNIT(t)->load_state != UNIT_LOADED)
 475                         continue;
 476
 477                 if (t->sysv_start_priority < 0)
 478                         continue;
 479
 480                 /* If both units have modern headers we don't care
 481                  * about the priorities */
 482                 if ((UNIT(s)->fragment_path || s->sysv_has_lsb) &&
 483                     (UNIT(t)->fragment_path || t->sysv_has_lsb))
 484                         continue;
 485
 486                 special_s = s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels);
 487                 special_t = t->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, t->sysv_runlevels);
 488
 489                 if (special_t && !special_s)
 490                         d = UNIT_AFTER;
 491                 else if (special_s && !special_t)
 492                         d = UNIT_BEFORE;
 493                 else if (t->sysv_start_priority < s->sysv_start_priority)
 494                         d = UNIT_AFTER;
 495                 else if (t->sysv_start_priority > s->sysv_start_priority)
 496                         d = UNIT_BEFORE;
 497                 else
 498                         continue;
 499
 500                 /* FIXME: Maybe we should compare the name here lexicographically? */
 501
 502                 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
 503                         return r;
 504         }
 505
 506         return 0;
 507 }
 508
 509 static ExecCommand *exec_command_new(const char *path, const char *arg1) {
 510         ExecCommand *c;
 511
 512         if (!(c = new0(ExecCommand, 1)))
 513                 return NULL;
 514
 515         if (!(c->path = strdup(path))) {
 516                 free(c);
 517                 return NULL;
 518         }
 519
 520         if (!(c->argv = strv_new(path, arg1, NULL))) {
 521                 free(c->path);
 522                 free(c);
 523                 return NULL;
 524         }
 525
 526         return c;
 527 }
 528
 529 static int sysv_exec_commands(Service *s) {
 530         ExecCommand *c;
 531
 532         assert(s);
 533         assert(s->is_sysv);
 534         assert(UNIT(s)->source_path);
 535
 536         c = exec_command_new(UNIT(s)->source_path, "start");
 537         if (!c)
 538                 return -ENOMEM;
 539         exec_command_append_list(s->exec_command+SERVICE_EXEC_START, c);
 540
 541         c = exec_command_new(UNIT(s)->source_path, "stop");
 542         if (!c)
 543                 return -ENOMEM;
 544         exec_command_append_list(s->exec_command+SERVICE_EXEC_STOP, c);
 545
 546         c = exec_command_new(UNIT(s)->source_path, "reload");
 547         if (!c)
 548                 return -ENOMEM;
 549         exec_command_append_list(s->exec_command+SERVICE_EXEC_RELOAD, c);
 550
 551         return 0;
 552 }
 553
 554 static int service_load_sysv_path(Service *s, const char *path) {
 555         FILE *f;
 556         Unit *u;
 557         unsigned line = 0;
 558         int r;
 559         enum {
 560                 NORMAL,
 561                 DESCRIPTION,
 562                 LSB,
 563                 LSB_DESCRIPTION
 564         } state = NORMAL;
 565         char *short_description = NULL, *long_description = NULL, *chkconfig_description = NULL, *description;
 566         struct stat st;
 567
 568         assert(s);
 569         assert(path);
 570
 571         u = UNIT(s);
 572
 573         f = fopen(path, "re");
 574         if (!f) {
 575                 r = errno == ENOENT ? 0 : -errno;
 576                 goto finish;
 577         }
 578
 579         if (fstat(fileno(f), &st) < 0) {
 580                 r = -errno;
 581                 goto finish;
 582         }
 583
 584         free(u->source_path);
 585         u->source_path = strdup(path);
 586         if (!u->source_path) {
 587                 r = -ENOMEM;
 588                 goto finish;
 589         }
 590         u->source_mtime = timespec_load(&st.st_mtim);
 591
 592         if (null_or_empty(&st)) {
 593                 u->load_state = UNIT_MASKED;
 594                 r = 0;
 595                 goto finish;
 596         }
 597
 598         s->is_sysv = true;
 599
 600         while (!feof(f)) {
 601                 char l[LINE_MAX], *t;
 602
 603                 if (!fgets(l, sizeof(l), f)) {
 604                         if (feof(f))
 605                                 break;
 606
 607                         r = -errno;
 608                         log_error("Failed to read configuration file '%s': %s", path, strerror(-r));
 609                         goto finish;
 610                 }
 611
 612                 line++;
 613
 614                 t = strstrip(l);
 615                 if (*t != '#')
 616                         continue;
 617
 618                 if (state == NORMAL && streq(t, "### BEGIN INIT INFO")) {
 619                         state = LSB;
 620                         s->sysv_has_lsb = true;
 621                         continue;
 622                 }
 623
 624                 if ((state == LSB_DESCRIPTION || state == LSB) && streq(t, "### END INIT INFO")) {
 625                         state = NORMAL;
 626                         continue;
 627                 }
 628
 629                 t++;
 630                 t += strspn(t, WHITESPACE);
 631
 632                 if (state == NORMAL) {
 633
 634                         /* Try to parse Red Hat style chkconfig headers */
 635
 636                         if (startswith_no_case(t, "chkconfig:")) {
 637                                 int start_priority;
 638                                 char runlevels[16], *k;
 639
 640                                 state = NORMAL;
 641
 642                                 if (sscanf(t+10, "%15s %i %*i",
 643                                            runlevels,
 644                                            &start_priority) != 2) {
 645
 646                                         log_warning("[%s:%u] Failed to parse chkconfig line. Ignoring.", path, line);
 647                                         continue;
 648                                 }
 649
 650                                 /* A start priority gathered from the
 651                                  * symlink farms is preferred over the
 652                                  * data from the LSB header. */
 653                                 if (start_priority < 0 || start_priority > 99)
 654                                         log_warning("[%s:%u] Start priority out of range. Ignoring.", path, line);
 655                                 else
 656                                         s->sysv_start_priority = start_priority;
 657
 658                                 char_array_0(runlevels);
 659                                 k = delete_chars(runlevels, WHITESPACE "-");
 660
 661                                 if (k[0]) {
 662                                         char *d;
 663
 664                                         if (!(d = strdup(k))) {
 665                                                 r = -ENOMEM;
 666                                                 goto finish;
 667                                         }
 668
 669                                         free(s->sysv_runlevels);
 670                                         s->sysv_runlevels = d;
 671                                 }
 672
 673                         } else if (startswith_no_case(t, "description:")) {
 674
 675                                 size_t k = strlen(t);
 676                                 char *d;
 677                                 const char *j;
 678
 679                                 if (t[k-1] == '\\') {
 680                                         state = DESCRIPTION;
 681                                         t[k-1] = 0;
 682                                 }
 683
 684                                 if ((j = strstrip(t+12)) && *j) {
 685                                         if (!(d = strdup(j))) {
 686                                                 r = -ENOMEM;
 687                                                 goto finish;
 688                                         }
 689                                 } else
 690                                         d = NULL;
 691
 692                                 free(chkconfig_description);
 693                                 chkconfig_description = d;
 694
 695                         } else if (startswith_no_case(t, "pidfile:")) {
 696
 697                                 char *fn;
 698
 699                                 state = NORMAL;
 700
 701                                 fn = strstrip(t+8);
 702                                 if (!path_is_absolute(fn)) {
 703                                         log_warning("[%s:%u] PID file not absolute. Ignoring.", path, line);
 704                                         continue;
 705                                 }
 706
 707                                 if (!(fn = strdup(fn))) {
 708                                         r = -ENOMEM;
 709                                         goto finish;
 710                                 }
 711
 712                                 free(s->pid_file);
 713                                 s->pid_file = fn;
 714                         }
 715
 716                 } else if (state == DESCRIPTION) {
 717
 718                         /* Try to parse Red Hat style description
 719                          * continuation */
 720
 721                         size_t k = strlen(t);
 722                         char *j;
 723
 724                         if (t[k-1] == '\\')
 725                                 t[k-1] = 0;
 726                         else
 727                                 state = NORMAL;
 728
 729                         if ((j = strstrip(t)) && *j) {
 730                                 char *d = NULL;
 731
 732                                 if (chkconfig_description)
 733                                         d = strjoin(chkconfig_description, " ", j, NULL);
 734                                 else
 735                                         d = strdup(j);
 736
 737                                 if (!d) {
 738                                         r = -ENOMEM;
 739                                         goto finish;
 740                                 }
 741
 742                                 free(chkconfig_description);
 743                                 chkconfig_description = d;
 744                         }
 745
 746                 } else if (state == LSB || state == LSB_DESCRIPTION) {
 747
 748                         if (startswith_no_case(t, "Provides:")) {
 749                                 char *i, *w;
 750                                 size_t z;
 751
 752                                 state = LSB;
 753
 754                                 FOREACH_WORD_QUOTED(w, z, t+9, i) {
 755                                         char *n, *m;
 756
 757                                         if (!(n = strndup(w, z))) {
 758                                                 r = -ENOMEM;
 759                                                 goto finish;
 760                                         }
 761
 762                                         r = sysv_translate_facility(n, path_get_file_name(path), &m);
 763                                         free(n);
 764
 765                                         if (r < 0)
 766                                                 goto finish;
 767
 768                                         if (r == 0)
 769                                                 continue;
 770
 771                                         if (unit_name_to_type(m) == UNIT_SERVICE)
 772                                                 r = unit_add_name(u, m);
 773                                         else
 774                                                 /* NB: SysV targets
 775                                                  * which are provided
 776                                                  * by a service are
 777                                                  * pulled in by the
 778                                                  * services, as an
 779                                                  * indication that the
 780                                                  * generic service is
 781                                                  * now available. This
 782                                                  * is strictly
 783                                                  * one-way. The
 784                                                  * targets do NOT pull
 785                                                  * in the SysV
 786                                                  * services! */
 787                                                 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_WANTS, m, NULL, true);
 788
 789                                         if (r < 0)
 790                                                 log_error("[%s:%u] Failed to add LSB Provides name %s, ignoring: %s", path, line, m, strerror(-r));
 791
 792                                         free(m);
 793                                 }
 794
 795                         } else if (startswith_no_case(t, "Required-Start:") ||
 796                                    startswith_no_case(t, "Should-Start:") ||
 797                                    startswith_no_case(t, "X-Start-Before:") ||
 798                                    startswith_no_case(t, "X-Start-After:")) {
 799                                 char *i, *w;
 800                                 size_t z;
 801
 802                                 state = LSB;
 803
 804                                 FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
 805                                         char *n, *m;
 806
 807                                         if (!(n = strndup(w, z))) {
 808                                                 r = -ENOMEM;
 809                                                 goto finish;
 810                                         }
 811
 812                                         r = sysv_translate_facility(n, path_get_file_name(path), &m);
 813
 814                                         if (r < 0) {
 815                                                 log_error("[%s:%u] Failed to translate LSB dependency %s, ignoring: %s", path, line, n, strerror(-r));
 816                                                 free(n);
 817                                                 continue;
 818                                         }
 819
 820                                         free(n);
 821
 822                                         if (r == 0)
 823                                                 continue;
 824
 825                                         r = unit_add_dependency_by_name(u, startswith_no_case(t, "X-Start-Before:") ? UNIT_BEFORE : UNIT_AFTER, m, NULL, true);
 826
 827                                         if (r < 0)
 828                                                 log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", path, line, m, strerror(-r));
 829
 830                                         free(m);
 831                                 }
 832                         } else if (startswith_no_case(t, "Default-Start:")) {
 833                                 char *k, *d;
 834
 835                                 state = LSB;
 836
 837                                 k = delete_chars(t+14, WHITESPACE "-");
 838
 839                                 if (k[0] != 0) {
 840                                         if (!(d = strdup(k))) {
 841                                                 r = -ENOMEM;
 842                                                 goto finish;
 843                                         }
 844
 845                                         free(s->sysv_runlevels);
 846                                         s->sysv_runlevels = d;
 847                                 }
 848
 849                         } else if (startswith_no_case(t, "Description:")) {
 850                                 char *d, *j;
 851
 852                                 state = LSB_DESCRIPTION;
 853
 854                                 if ((j = strstrip(t+12)) && *j) {
 855                                         if (!(d = strdup(j))) {
 856                                                 r = -ENOMEM;
 857                                                 goto finish;
 858                                         }
 859                                 } else
 860                                         d = NULL;
 861
 862                                 free(long_description);
 863                                 long_description = d;
 864
 865                         } else if (startswith_no_case(t, "Short-Description:")) {
 866                                 char *d, *j;
 867
 868                                 state = LSB;
 869
 870                                 if ((j = strstrip(t+18)) && *j) {
 871                                         if (!(d = strdup(j))) {
 872                                                 r = -ENOMEM;
 873                                                 goto finish;
 874                                         }
 875                                 } else
 876                                         d = NULL;
 877
 878                                 free(short_description);
 879                                 short_description = d;
 880
 881                         } else if (state == LSB_DESCRIPTION) {
 882
 883                                 if (startswith(l, "#\t") || startswith(l, "#  ")) {
 884                                         char *j;
 885
 886                                         if ((j = strstrip(t)) && *j) {
 887                                                 char *d = NULL;
 888
 889                                                 if (long_description)
 890                                                         d = strjoin(long_description, " ", t, NULL);
 891                                                 else
 892                                                         d = strdup(j);
 893
 894                                                 if (!d) {
 895                                                         r = -ENOMEM;
 896                                                         goto finish;
 897                                                 }
 898
 899                                                 free(long_description);
 900                                                 long_description = d;
 901                                         }
 902
 903                                 } else
 904                                         state = LSB;
 905                         }
 906                 }
 907         }
 908
 909         if ((r = sysv_exec_commands(s)) < 0)
 910                 goto finish;
 911         if (s->sysv_runlevels &&
 912             chars_intersect(RUNLEVELS_BOOT, s->sysv_runlevels) &&
 913             chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
 914                 /* Service has both boot and "up" runlevels
 915                    configured.  Kill the "up" ones. */
 916                 delete_chars(s->sysv_runlevels, RUNLEVELS_UP);
 917         }
 918
 919         if (s->sysv_runlevels && !chars_intersect(RUNLEVELS_UP, s->sysv_runlevels)) {
 920                 /* If there a runlevels configured for this service
 921                  * but none of the standard ones, then we assume this
 922                  * is some special kind of service (which might be
 923                  * needed for early boot) and don't create any links
 924                  * to it. */
 925
 926                 UNIT(s)->default_dependencies = false;
 927
 928                 /* Don't timeout special services during boot (like fsck) */
 929                 s->timeout_start_usec = 0;
 930                 s->timeout_stop_usec = 0;
 931         } else {
 932                 s->timeout_start_usec = DEFAULT_SYSV_TIMEOUT_USEC;
 933                 s->timeout_stop_usec = DEFAULT_SYSV_TIMEOUT_USEC;
 934         }
 935
 936         /* Special setting for all SysV services */
 937         s->type = SERVICE_FORKING;
 938         s->remain_after_exit = !s->pid_file;
 939         s->guess_main_pid = false;
 940         s->restart = SERVICE_RESTART_NO;
 941         s->exec_context.ignore_sigpipe = false;
 942         s->kill_context.kill_mode = KILL_PROCESS;
 943
 944         /* We use the long description only if
 945          * no short description is set. */
 946
 947         if (short_description)
 948                 description = short_description;
 949         else if (chkconfig_description)
 950                 description = chkconfig_description;
 951         else if (long_description)
 952                 description = long_description;
 953         else
 954                 description = NULL;
 955
 956         if (description) {
 957                 char *d;
 958
 959                 if (!(d = strappend(s->sysv_has_lsb ? "LSB: " : "SYSV: ", description))) {
 960                         r = -ENOMEM;
 961                         goto finish;
 962                 }
 963
 964                 u->description = d;
 965         }
 966
 967         /* The priority that has been set in /etc/rcN.d/ hierarchies
 968          * takes precedence over what is stored as default in the LSB
 969          * header */
 970         if (s->sysv_start_priority_from_rcnd >= 0)
 971                 s->sysv_start_priority = s->sysv_start_priority_from_rcnd;
 972
 973         u->load_state = UNIT_LOADED;
 974         r = 0;
 975
 976 finish:
 977
 978         if (f)
 979                 fclose(f);
 980
 981         free(short_description);
 982         free(long_description);
 983         free(chkconfig_description);
 984
 985         return r;
 986 }
 987
 988 static int service_load_sysv_name(Service *s, const char *name) {
 989         char **p;
 990
 991         assert(s);
 992         assert(name);
 993
 994         /* For SysV services we strip the boot.*, rc.* and *.sh
 995          * prefixes/suffixes. */
 996 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
 997         if (endswith(name, ".sh.service"))
 998                 return -ENOENT;
 999 #endif
1000
1001 #ifdef TARGET_SUSE
1002         if (startswith(name, "boot."))
1003                 return -ENOENT;
1004 #endif
1005
1006 #ifdef TARGET_FRUGALWARE
1007         if (startswith(name, "rc."))
1008                 return -ENOENT;
1009 #endif
1010
1011         STRV_FOREACH(p, UNIT(s)->manager->lookup_paths.sysvinit_path) {
1012                 char *path;
1013                 int r;
1014
1015                 path = strjoin(*p, "/", name, NULL);
1016                 if (!path)
1017                         return -ENOMEM;
1018
1019                 assert(endswith(path, ".service"));
1020                 path[strlen(path)-8] = 0;
1021
1022                 r = service_load_sysv_path(s, path);
1023
1024 #if defined(TARGET_DEBIAN) || defined(TARGET_UBUNTU) || defined(TARGET_ANGSTROM)
1025                 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1026                         /* Try Debian style *.sh source'able init scripts */
1027                         strcat(path, ".sh");
1028                         r = service_load_sysv_path(s, path);
1029                 }
1030 #endif
1031                 free(path);
1032
1033 #ifdef TARGET_SUSE
1034                 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1035                         /* Try SUSE style boot.* init scripts */
1036
1037                         path = strjoin(*p, "/boot.", name, NULL);
1038                         if (!path)
1039                                 return -ENOMEM;
1040
1041                         /* Drop .service suffix */
1042                         path[strlen(path)-8] = 0;
1043                         r = service_load_sysv_path(s, path);
1044                         free(path);
1045                 }
1046 #endif
1047
1048 #ifdef TARGET_FRUGALWARE
1049                 if (r >= 0 && UNIT(s)->load_state == UNIT_STUB) {
1050                         /* Try Frugalware style rc.* init scripts */
1051
1052                         path = strjoin(*p, "/rc.", name, NULL);
1053                         if (!path)
1054                                 return -ENOMEM;
1055
1056                         /* Drop .service suffix */
1057                         path[strlen(path)-8] = 0;
1058                         r = service_load_sysv_path(s, path);
1059                         free(path);
1060                 }
1061 #endif
1062
1063                 if (r < 0)
1064                         return r;
1065
1066                 if ((UNIT(s)->load_state != UNIT_STUB))
1067                         break;
1068         }
1069
1070         return 0;
1071 }
1072
1073 static int service_load_sysv(Service *s) {
1074         const char *t;
1075         Iterator i;
1076         int r;
1077
1078         assert(s);
1079
1080         /* Load service data from SysV init scripts, preferably with
1081          * LSB headers ... */
1082
1083         if (strv_isempty(UNIT(s)->manager->lookup_paths.sysvinit_path))
1084                 return 0;
1085
1086         if ((t = UNIT(s)->id))
1087                 if ((r = service_load_sysv_name(s, t)) < 0)
1088                         return r;
1089
1090         if (UNIT(s)->load_state == UNIT_STUB)
1091                 SET_FOREACH(t, UNIT(s)->names, i) {
1092                         if (t == UNIT(s)->id)
1093                                 continue;
1094
1095                         if ((r = service_load_sysv_name(s, t)) < 0)
1096                                 return r;
1097
1098                         if (UNIT(s)->load_state != UNIT_STUB)
1099                                 break;
1100                 }
1101
1102         return 0;
1103 }
1104 #endif
1105
1106 static int fsck_fix_order(Service *s) {
1107         Unit *other;
1108         int r;
1109
1110         assert(s);
1111
1112         if (s->fsck_passno <= 0)
1113                 return 0;
1114
1115         /* For each pair of services where both have an fsck priority
1116          * we order things based on it. */
1117
1118         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_SERVICE]) {
1119                 Service *t;
1120                 UnitDependency d;
1121
1122                 t = SERVICE(other);
1123
1124                 if (s == t)
1125                         continue;
1126
1127                 if (UNIT(t)->load_state != UNIT_LOADED)
1128                         continue;
1129
1130                 if (t->fsck_passno <= 0)
1131                         continue;
1132
1133                 if (t->fsck_passno < s->fsck_passno)
1134                         d = UNIT_AFTER;
1135                 else if (t->fsck_passno > s->fsck_passno)
1136                         d = UNIT_BEFORE;
1137                 else
1138                         continue;
1139
1140                 if ((r = unit_add_dependency(UNIT(s), d, UNIT(t), true)) < 0)
1141                         return r;
1142         }
1143
1144         return 0;
1145 }
1146
1147 static int service_verify(Service *s) {
1148         assert(s);
1149
1150         if (UNIT(s)->load_state != UNIT_LOADED)
1151                 return 0;
1152
1153         if (!s->exec_command[SERVICE_EXEC_START]) {
1154                 log_error("%s lacks ExecStart setting. Refusing.", UNIT(s)->id);
1155                 return -EINVAL;
1156         }
1157
1158         if (s->type != SERVICE_ONESHOT &&
1159             s->exec_command[SERVICE_EXEC_START]->command_next) {
1160                 log_error("%s has more than one ExecStart setting, which is only allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1161                 return -EINVAL;
1162         }
1163
1164         if (s->type == SERVICE_ONESHOT &&
1165             s->exec_command[SERVICE_EXEC_RELOAD]) {
1166                 log_error("%s has an ExecReload setting, which is not allowed for Type=oneshot services. Refusing.", UNIT(s)->id);
1167                 return -EINVAL;
1168         }
1169
1170         if (s->type == SERVICE_DBUS && !s->bus_name) {
1171                 log_error("%s is of type D-Bus but no D-Bus service name has been specified. Refusing.", UNIT(s)->id);
1172                 return -EINVAL;
1173         }
1174
1175         if (s->bus_name && s->type != SERVICE_DBUS)
1176                 log_warning("%s has a D-Bus service name specified, but is not of type dbus. Ignoring.", UNIT(s)->id);
1177
1178         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
1179                 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1180                 return -EINVAL;
1181         }
1182
1183         return 0;
1184 }
1185
1186 static int service_add_default_dependencies(Service *s) {
1187         int r;
1188
1189         assert(s);
1190
1191         /* Add a number of automatic dependencies useful for the
1192          * majority of services. */
1193
1194         /* First, pull in base system */
1195         if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
1196
1197                 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
1198                         return r;
1199
1200         } else if (UNIT(s)->manager->running_as == SYSTEMD_USER) {
1201
1202                 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
1203                         return r;
1204         }
1205
1206         /* Second, activate normal shutdown */
1207         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
1208 }
1209
1210 static void service_fix_output(Service *s) {
1211         assert(s);
1212
1213         /* If nothing has been explicitly configured, patch default
1214          * output in. If input is socket/tty we avoid this however,
1215          * since in that case we want output to default to the same
1216          * place as we read input from. */
1217
1218         if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1219             s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1220             s->exec_context.std_input == EXEC_INPUT_NULL)
1221                 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1222
1223         if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1224             s->exec_context.std_input == EXEC_INPUT_NULL)
1225                 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1226 }
1227
1228 static int service_load(Unit *u) {
1229         int r;
1230         Service *s = SERVICE(u);
1231
1232         assert(s);
1233
1234         /* Load a .service file */
1235         if ((r = unit_load_fragment(u)) < 0)
1236                 return r;
1237
1238 #ifdef HAVE_SYSV_COMPAT
1239         /* Load a classic init script as a fallback, if we couldn't find anything */
1240         if (u->load_state == UNIT_STUB)
1241                 if ((r = service_load_sysv(s)) < 0)
1242                         return r;
1243 #endif
1244
1245         /* Still nothing found? Then let's give up */
1246         if (u->load_state == UNIT_STUB)
1247                 return -ENOENT;
1248
1249         /* We were able to load something, then let's add in the
1250          * dropin directories. */
1251         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
1252                 return r;
1253
1254         /* This is a new unit? Then let's add in some extras */
1255         if (u->load_state == UNIT_LOADED) {
1256                 if (s->type == _SERVICE_TYPE_INVALID)
1257                         s->type = s->bus_name ? SERVICE_DBUS : SERVICE_SIMPLE;
1258
1259                 /* Oneshot services have disabled start timeout by default */
1260                 if (s->type == SERVICE_ONESHOT && !s->start_timeout_defined)
1261                         s->timeout_start_usec = 0;
1262
1263                 service_fix_output(s);
1264
1265                 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
1266                         return r;
1267
1268                 if ((r = unit_add_default_cgroups(u)) < 0)
1269                         return r;
1270
1271 #ifdef HAVE_SYSV_COMPAT
1272                 if ((r = sysv_fix_order(s)) < 0)
1273                         return r;
1274 #endif
1275
1276                 if ((r = fsck_fix_order(s)) < 0)
1277                         return r;
1278
1279                 if (s->bus_name)
1280                         if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1281                                 return r;
1282
1283                 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1284                         s->notify_access = NOTIFY_MAIN;
1285
1286                 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1287                         s->notify_access = NOTIFY_MAIN;
1288
1289                 if (s->type == SERVICE_DBUS || s->bus_name)
1290                         if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true)) < 0)
1291                                 return r;
1292
1293                 if (UNIT(s)->default_dependencies)
1294                         if ((r = service_add_default_dependencies(s)) < 0)
1295                                 return r;
1296
1297                 r = unit_exec_context_defaults(u, &s->exec_context);
1298                 if (r < 0)
1299                         return r;
1300         }
1301
1302         return service_verify(s);
1303 }
1304
1305 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1306
1307         ServiceExecCommand c;
1308         Service *s = SERVICE(u);
1309         const char *prefix2;
1310         char *p2;
1311
1312         assert(s);
1313
1314         p2 = strappend(prefix, "\t");
1315         prefix2 = p2 ? p2 : prefix;
1316
1317         fprintf(f,
1318                 "%sService State: %s\n"
1319                 "%sResult: %s\n"
1320                 "%sReload Result: %s\n"
1321                 "%sPermissionsStartOnly: %s\n"
1322                 "%sRootDirectoryStartOnly: %s\n"
1323                 "%sRemainAfterExit: %s\n"
1324                 "%sGuessMainPID: %s\n"
1325                 "%sType: %s\n"
1326                 "%sRestart: %s\n"
1327                 "%sNotifyAccess: %s\n",
1328                 prefix, service_state_to_string(s->state),
1329                 prefix, service_result_to_string(s->result),
1330                 prefix, service_result_to_string(s->reload_result),
1331                 prefix, yes_no(s->permissions_start_only),
1332                 prefix, yes_no(s->root_directory_start_only),
1333                 prefix, yes_no(s->remain_after_exit),
1334                 prefix, yes_no(s->guess_main_pid),
1335                 prefix, service_type_to_string(s->type),
1336                 prefix, service_restart_to_string(s->restart),
1337                 prefix, notify_access_to_string(s->notify_access));
1338
1339         if (s->control_pid > 0)
1340                 fprintf(f,
1341                         "%sControl PID: %lu\n",
1342                         prefix, (unsigned long) s->control_pid);
1343
1344         if (s->main_pid > 0)
1345                 fprintf(f,
1346                         "%sMain PID: %lu\n"
1347                         "%sMain PID Known: %s\n"
1348                         "%sMain PID Alien: %s\n",
1349                         prefix, (unsigned long) s->main_pid,
1350                         prefix, yes_no(s->main_pid_known),
1351                         prefix, yes_no(s->main_pid_alien));
1352
1353         if (s->pid_file)
1354                 fprintf(f,
1355                         "%sPIDFile: %s\n",
1356                         prefix, s->pid_file);
1357
1358         if (s->bus_name)
1359                 fprintf(f,
1360                         "%sBusName: %s\n"
1361                         "%sBus Name Good: %s\n",
1362                         prefix, s->bus_name,
1363                         prefix, yes_no(s->bus_name_good));
1364
1365         kill_context_dump(&s->kill_context, f, prefix);
1366         exec_context_dump(&s->exec_context, f, prefix);
1367
1368         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1369
1370                 if (!s->exec_command[c])
1371                         continue;
1372
1373                 fprintf(f, "%s-> %s:\n",
1374                         prefix, service_exec_command_to_string(c));
1375
1376                 exec_command_dump_list(s->exec_command[c], f, prefix2);
1377         }
1378
1379 #ifdef HAVE_SYSV_COMPAT
1380         if (s->is_sysv)
1381                 fprintf(f,
1382                         "%sSysV Init Script has LSB Header: %s\n"
1383                         "%sSysVEnabled: %s\n",
1384                         prefix, yes_no(s->sysv_has_lsb),
1385                         prefix, yes_no(s->sysv_enabled));
1386
1387         if (s->sysv_start_priority >= 0)
1388                 fprintf(f,
1389                         "%sSysVStartPriority: %i\n",
1390                         prefix, s->sysv_start_priority);
1391
1392         if (s->sysv_runlevels)
1393                 fprintf(f, "%sSysVRunLevels: %s\n",
1394                         prefix, s->sysv_runlevels);
1395 #endif
1396
1397         if (s->fsck_passno > 0)
1398                 fprintf(f,
1399                         "%sFsckPassNo: %i\n",
1400                         prefix, s->fsck_passno);
1401
1402         if (s->status_text)
1403                 fprintf(f, "%sStatus Text: %s\n",
1404                         prefix, s->status_text);
1405
1406         free(p2);
1407 }
1408
1409 static int service_load_pid_file(Service *s, bool may_warn) {
1410         char *k;
1411         int r;
1412         pid_t pid;
1413
1414         assert(s);
1415
1416         if (!s->pid_file)
1417                 return -ENOENT;
1418
1419         if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1420                 if (may_warn)
1421                         log_info("PID file %s not readable (yet?) after %s.",
1422                                  s->pid_file, service_state_to_string(s->state));
1423                 return r;
1424         }
1425
1426         r = parse_pid(k, &pid);
1427         free(k);
1428
1429         if (r < 0)
1430                 return r;
1431
1432         if (kill(pid, 0) < 0 && errno != EPERM) {
1433                 if (may_warn)
1434                         log_info("PID %lu read from file %s does not exist.",
1435                                  (unsigned long) pid, s->pid_file);
1436                 return -ESRCH;
1437         }
1438
1439         if (s->main_pid_known) {
1440                 if (pid == s->main_pid)
1441                         return 0;
1442
1443                 log_debug("Main PID changing: %lu -> %lu",
1444                           (unsigned long) s->main_pid, (unsigned long) pid);
1445                 service_unwatch_main_pid(s);
1446                 s->main_pid_known = false;
1447         } else
1448                 log_debug("Main PID loaded: %lu", (unsigned long) pid);
1449
1450         if ((r = service_set_main_pid(s, pid)) < 0)
1451                 return r;
1452
1453         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1454                 /* FIXME: we need to do something here */
1455                 return r;
1456
1457         return 0;
1458 }
1459
1460 static int service_search_main_pid(Service *s) {
1461         pid_t pid;
1462         int r;
1463
1464         assert(s);
1465
1466         /* If we know it anyway, don't ever fallback to unreliable
1467          * heuristics */
1468         if (s->main_pid_known)
1469                 return 0;
1470
1471         if (!s->guess_main_pid)
1472                 return 0;
1473
1474         assert(s->main_pid <= 0);
1475
1476         if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1477                 return -ENOENT;
1478
1479         log_debug("Main PID guessed: %lu", (unsigned long) pid);
1480         if ((r = service_set_main_pid(s, pid)) < 0)
1481                 return r;
1482
1483         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1484                 /* FIXME: we need to do something here */
1485                 return r;
1486
1487         return 0;
1488 }
1489
1490 static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1491         Iterator i;
1492         Unit *u;
1493
1494         assert(s);
1495
1496         /* Notifies all our sockets when we die */
1497
1498         if (s->socket_fd >= 0)
1499                 return;
1500
1501         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1502                 if (u->type == UNIT_SOCKET)
1503                         socket_notify_service_dead(SOCKET(u), failed_permanent);
1504
1505         return;
1506 }
1507
1508 static void service_set_state(Service *s, ServiceState state) {
1509         ServiceState old_state;
1510         const UnitActiveState *table;
1511         assert(s);
1512
1513         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1514
1515         old_state = s->state;
1516         s->state = state;
1517
1518         service_unwatch_pid_file(s);
1519
1520         if (state != SERVICE_START_PRE &&
1521             state != SERVICE_START &&
1522             state != SERVICE_START_POST &&
1523             state != SERVICE_RELOAD &&
1524             state != SERVICE_STOP &&
1525             state != SERVICE_STOP_SIGTERM &&
1526             state != SERVICE_STOP_SIGKILL &&
1527             state != SERVICE_STOP_POST &&
1528             state != SERVICE_FINAL_SIGTERM &&
1529             state != SERVICE_FINAL_SIGKILL &&
1530             state != SERVICE_AUTO_RESTART)
1531                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1532
1533         if (state != SERVICE_START &&
1534             state != SERVICE_START_POST &&
1535             state != SERVICE_RUNNING &&
1536             state != SERVICE_RELOAD &&
1537             state != SERVICE_STOP &&
1538             state != SERVICE_STOP_SIGTERM &&
1539             state != SERVICE_STOP_SIGKILL) {
1540                 service_unwatch_main_pid(s);
1541                 s->main_command = NULL;
1542         }
1543
1544         if (state != SERVICE_START_PRE &&
1545             state != SERVICE_START &&
1546             state != SERVICE_START_POST &&
1547             state != SERVICE_RELOAD &&
1548             state != SERVICE_STOP &&
1549             state != SERVICE_STOP_SIGTERM &&
1550             state != SERVICE_STOP_SIGKILL &&
1551             state != SERVICE_STOP_POST &&
1552             state != SERVICE_FINAL_SIGTERM &&
1553             state != SERVICE_FINAL_SIGKILL) {
1554                 service_unwatch_control_pid(s);
1555                 s->control_command = NULL;
1556                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1557         }
1558
1559         if (state == SERVICE_DEAD ||
1560             state == SERVICE_STOP ||
1561             state == SERVICE_STOP_SIGTERM ||
1562             state == SERVICE_STOP_SIGKILL ||
1563             state == SERVICE_STOP_POST ||
1564             state == SERVICE_FINAL_SIGTERM ||
1565             state == SERVICE_FINAL_SIGKILL ||
1566             state == SERVICE_FAILED ||
1567             state == SERVICE_AUTO_RESTART)
1568                 service_notify_sockets_dead(s, false);
1569
1570         if (state != SERVICE_START_PRE &&
1571             state != SERVICE_START &&
1572             state != SERVICE_START_POST &&
1573             state != SERVICE_RUNNING &&
1574             state != SERVICE_RELOAD &&
1575             state != SERVICE_STOP &&
1576             state != SERVICE_STOP_SIGTERM &&
1577             state != SERVICE_STOP_SIGKILL &&
1578             state != SERVICE_STOP_POST &&
1579             state != SERVICE_FINAL_SIGTERM &&
1580             state != SERVICE_FINAL_SIGKILL &&
1581             !(state == SERVICE_DEAD && UNIT(s)->job)) {
1582                 service_close_socket_fd(s);
1583                 service_connection_unref(s);
1584         }
1585
1586         if (state == SERVICE_STOP)
1587                 service_stop_watchdog(s);
1588
1589         /* For the inactive states unit_notify() will trim the cgroup,
1590          * but for exit we have to do that ourselves... */
1591         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1592                 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1593
1594         if (old_state != state)
1595                 log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1596
1597         unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1598         s->reload_result = SERVICE_SUCCESS;
1599 }
1600
1601 static int service_coldplug(Unit *u) {
1602         Service *s = SERVICE(u);
1603         int r;
1604
1605         assert(s);
1606         assert(s->state == SERVICE_DEAD);
1607
1608         if (s->deserialized_state != s->state) {
1609
1610                 if (s->deserialized_state == SERVICE_START_PRE ||
1611                     s->deserialized_state == SERVICE_START ||
1612                     s->deserialized_state == SERVICE_START_POST ||
1613                     s->deserialized_state == SERVICE_RELOAD ||
1614                     s->deserialized_state == SERVICE_STOP ||
1615                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1616                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1617                     s->deserialized_state == SERVICE_STOP_POST ||
1618                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1619                     s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1620                     s->deserialized_state == SERVICE_AUTO_RESTART) {
1621                         if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_start_usec > 0) {
1622                                 usec_t k;
1623
1624                                 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_start_usec;
1625
1626                                 if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1627                                         return r;
1628                         }
1629                 }
1630
1631                 if ((s->deserialized_state == SERVICE_START &&
1632                      (s->type == SERVICE_FORKING ||
1633                       s->type == SERVICE_DBUS ||
1634                       s->type == SERVICE_ONESHOT ||
1635                       s->type == SERVICE_NOTIFY)) ||
1636                     s->deserialized_state == SERVICE_START_POST ||
1637                     s->deserialized_state == SERVICE_RUNNING ||
1638                     s->deserialized_state == SERVICE_RELOAD ||
1639                     s->deserialized_state == SERVICE_STOP ||
1640                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1641                     s->deserialized_state == SERVICE_STOP_SIGKILL)
1642                         if (s->main_pid > 0)
1643                                 if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1644                                         return r;
1645
1646                 if (s->deserialized_state == SERVICE_START_PRE ||
1647                     s->deserialized_state == SERVICE_START ||
1648                     s->deserialized_state == SERVICE_START_POST ||
1649                     s->deserialized_state == SERVICE_RELOAD ||
1650                     s->deserialized_state == SERVICE_STOP ||
1651                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1652                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1653                     s->deserialized_state == SERVICE_STOP_POST ||
1654                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1655                     s->deserialized_state == SERVICE_FINAL_SIGKILL)
1656                         if (s->control_pid > 0)
1657                                 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1658                                         return r;
1659
1660                 if (s->deserialized_state == SERVICE_START_POST ||
1661                     s->deserialized_state == SERVICE_RUNNING)
1662                         service_handle_watchdog(s);
1663
1664                 service_set_state(s, s->deserialized_state);
1665         }
1666         return 0;
1667 }
1668
1669 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1670         Iterator i;
1671         int r;
1672         int *rfds = NULL;
1673         unsigned rn_fds = 0;
1674         Unit *u;
1675
1676         assert(s);
1677         assert(fds);
1678         assert(n_fds);
1679
1680         if (s->socket_fd >= 0)
1681                 return 0;
1682
1683         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1684                 int *cfds;
1685                 unsigned cn_fds;
1686                 Socket *sock;
1687
1688                 if (u->type != UNIT_SOCKET)
1689                         continue;
1690
1691                 sock = SOCKET(u);
1692
1693                 if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1694                         goto fail;
1695
1696                 if (!cfds)
1697                         continue;
1698
1699                 if (!rfds) {
1700                         rfds = cfds;
1701                         rn_fds = cn_fds;
1702                 } else {
1703                         int *t;
1704
1705                         if (!(t = new(int, rn_fds+cn_fds))) {
1706                                 free(cfds);
1707                                 r = -ENOMEM;
1708                                 goto fail;
1709                         }
1710
1711                         memcpy(t, rfds, rn_fds * sizeof(int));
1712                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1713                         free(rfds);
1714                         free(cfds);
1715
1716                         rfds = t;
1717                         rn_fds = rn_fds+cn_fds;
1718                 }
1719         }
1720
1721         *fds = rfds;
1722         *n_fds = rn_fds;
1723
1724         return 0;
1725
1726 fail:
1727         free(rfds);
1728
1729         return r;
1730 }
1731
1732 static int service_spawn(
1733                 Service *s,
1734                 ExecCommand *c,
1735                 bool timeout,
1736                 bool pass_fds,
1737                 bool apply_permissions,
1738                 bool apply_chroot,
1739                 bool apply_tty_stdin,
1740                 bool set_notify_socket,
1741                 bool is_control,
1742                 pid_t *_pid) {
1743
1744         pid_t pid;
1745         int r;
1746         int *fds = NULL, *fdsbuf = NULL;
1747         unsigned n_fds = 0, n_env = 0;
1748         char **argv = NULL, **final_env = NULL, **our_env = NULL;
1749
1750         assert(s);
1751         assert(c);
1752         assert(_pid);
1753
1754         if (pass_fds ||
1755             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1756             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1757             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1758
1759                 if (s->socket_fd >= 0) {
1760                         fds = &s->socket_fd;
1761                         n_fds = 1;
1762                 } else {
1763                         if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1764                                 goto fail;
1765
1766                         fds = fdsbuf;
1767                 }
1768         }
1769
1770         if (timeout && s->timeout_start_usec) {
1771                 r = unit_watch_timer(UNIT(s), s->timeout_start_usec, &s->timer_watch);
1772                 if (r < 0)
1773                         goto fail;
1774         } else
1775                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1776
1777         if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1778                 r = -ENOMEM;
1779                 goto fail;
1780         }
1781
1782         if (!(our_env = new0(char*, 4))) {
1783                 r = -ENOMEM;
1784                 goto fail;
1785         }
1786
1787         if (set_notify_socket)
1788                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1789                         r = -ENOMEM;
1790                         goto fail;
1791                 }
1792
1793         if (s->main_pid > 0)
1794                 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1795                         r = -ENOMEM;
1796                         goto fail;
1797                 }
1798
1799         if (s->watchdog_usec > 0)
1800                 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1801                         r = -ENOMEM;
1802                         goto fail;
1803                 }
1804
1805         if (!(final_env = strv_env_merge(2,
1806                                          UNIT(s)->manager->environment,
1807                                          our_env,
1808                                          NULL))) {
1809                 r = -ENOMEM;
1810                 goto fail;
1811         }
1812
1813         r = exec_spawn(c,
1814                        argv,
1815                        &s->exec_context,
1816                        fds, n_fds,
1817                        final_env,
1818                        apply_permissions,
1819                        apply_chroot,
1820                        apply_tty_stdin,
1821                        UNIT(s)->manager->confirm_spawn,
1822                        UNIT(s)->cgroup_bondings,
1823                        UNIT(s)->cgroup_attributes,
1824                        is_control ? "control" : NULL,
1825                        UNIT(s)->id,
1826                        s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1827                        &pid);
1828
1829         if (r < 0)
1830                 goto fail;
1831
1832         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1833                 /* FIXME: we need to do something here */
1834                 goto fail;
1835
1836         free(fdsbuf);
1837         strv_free(argv);
1838         strv_free(our_env);
1839         strv_free(final_env);
1840
1841         *_pid = pid;
1842
1843         return 0;
1844
1845 fail:
1846         free(fdsbuf);
1847         strv_free(argv);
1848         strv_free(our_env);
1849         strv_free(final_env);
1850
1851         if (timeout)
1852                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1853
1854         return r;
1855 }
1856
1857 static int main_pid_good(Service *s) {
1858         assert(s);
1859
1860         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1861          * don't know */
1862
1863         /* If we know the pid file, then lets just check if it is
1864          * still valid */
1865         if (s->main_pid_known) {
1866
1867                 /* If it's an alien child let's check if it is still
1868                  * alive ... */
1869                 if (s->main_pid_alien)
1870                         return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1871
1872                 /* .. otherwise assume we'll get a SIGCHLD for it,
1873                  * which we really should wait for to collect exit
1874                  * status and code */
1875                 return s->main_pid > 0;
1876         }
1877
1878         /* We don't know the pid */
1879         return -EAGAIN;
1880 }
1881
1882 static int control_pid_good(Service *s) {
1883         assert(s);
1884
1885         return s->control_pid > 0;
1886 }
1887
1888 static int cgroup_good(Service *s) {
1889         int r;
1890
1891         assert(s);
1892
1893         if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1894                 return r;
1895
1896         return !r;
1897 }
1898
1899 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1900         int r;
1901         assert(s);
1902
1903         if (f != SERVICE_SUCCESS)
1904                 s->result = f;
1905
1906         service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1907
1908         if (allow_restart &&
1909             !s->forbid_restart &&
1910             (s->restart == SERVICE_RESTART_ALWAYS ||
1911              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1912              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1913              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1914                                                          s->result == SERVICE_FAILURE_CORE_DUMP))) &&
1915             (s->result != SERVICE_FAILURE_EXIT_CODE ||
1916              !set_contains(s->restart_ignore_status.code, INT_TO_PTR(s->main_exec_status.status))) &&
1917             (s->result != SERVICE_FAILURE_SIGNAL ||
1918              !set_contains(s->restart_ignore_status.signal, INT_TO_PTR(s->main_exec_status.status)))
1919                 ) {
1920
1921                 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1922                 if (r < 0)
1923                         goto fail;
1924
1925                 service_set_state(s, SERVICE_AUTO_RESTART);
1926         }
1927
1928         s->forbid_restart = false;
1929
1930         return;
1931
1932 fail:
1933         log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1934         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1935 }
1936
1937 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1938
1939 static void service_enter_stop_post(Service *s, ServiceResult f) {
1940         int r;
1941         assert(s);
1942
1943         if (f != SERVICE_SUCCESS)
1944                 s->result = f;
1945
1946         service_unwatch_control_pid(s);
1947
1948         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1949                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1950
1951                 r = service_spawn(s,
1952                                   s->control_command,
1953                                   true,
1954                                   false,
1955                                   !s->permissions_start_only,
1956                                   !s->root_directory_start_only,
1957                                   true,
1958                                   false,
1959                                   true,
1960                                   &s->control_pid);
1961                 if (r < 0)
1962                         goto fail;
1963
1964
1965                 service_set_state(s, SERVICE_STOP_POST);
1966         } else
1967                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1968
1969         return;
1970
1971 fail:
1972         log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1973         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1974 }
1975
1976 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1977         int r;
1978         Set *pid_set = NULL;
1979         bool wait_for_exit = false;
1980
1981         assert(s);
1982
1983         if (f != SERVICE_SUCCESS)
1984                 s->result = f;
1985
1986         if (s->kill_context.kill_mode != KILL_NONE) {
1987                 int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1988
1989                 if (s->main_pid > 0) {
1990                         if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1991                                 log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1992                         else
1993                                 wait_for_exit = !s->main_pid_alien;
1994                 }
1995
1996                 if (s->control_pid > 0) {
1997                         if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1998                                 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1999                         else
2000                                 wait_for_exit = true;
2001                 }
2002
2003                 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
2004
2005                         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2006                         if (!pid_set) {
2007                                 r = -ENOMEM;
2008                                 goto fail;
2009                         }
2010
2011                         /* Exclude the main/control pids from being killed via the cgroup */
2012                         if (s->main_pid > 0)
2013                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
2014                                         goto fail;
2015
2016                         if (s->control_pid > 0)
2017                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
2018                                         goto fail;
2019
2020                         r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
2021                         if (r < 0) {
2022                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2023                                         log_warning("Failed to kill control group: %s", strerror(-r));
2024                         } else if (r > 0)
2025                                 wait_for_exit = true;
2026
2027                         set_free(pid_set);
2028                         pid_set = NULL;
2029                 }
2030         }
2031
2032         if (wait_for_exit) {
2033                 if (s->timeout_stop_usec > 0) {
2034                         r = unit_watch_timer(UNIT(s), s->timeout_stop_usec, &s->timer_watch);
2035                         if (r < 0)
2036                                 goto fail;
2037                 }
2038
2039                 service_set_state(s, state);
2040         } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2041                 service_enter_stop_post(s, SERVICE_SUCCESS);
2042         else
2043                 service_enter_dead(s, SERVICE_SUCCESS, true);
2044
2045         return;
2046
2047 fail:
2048         log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2049
2050         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2051                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2052         else
2053                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2054
2055         if (pid_set)
2056                 set_free(pid_set);
2057 }
2058
2059 static void service_enter_stop(Service *s, ServiceResult f) {
2060         int r;
2061
2062         assert(s);
2063
2064         if (f != SERVICE_SUCCESS)
2065                 s->result = f;
2066
2067         service_unwatch_control_pid(s);
2068
2069         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2070                 s->control_command_id = SERVICE_EXEC_STOP;
2071
2072                 r = service_spawn(s,
2073                                   s->control_command,
2074                                   true,
2075                                   false,
2076                                   !s->permissions_start_only,
2077                                   !s->root_directory_start_only,
2078                                   false,
2079                                   false,
2080                                   true,
2081                                   &s->control_pid);
2082                 if (r < 0)
2083                         goto fail;
2084
2085                 service_set_state(s, SERVICE_STOP);
2086         } else
2087                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2088
2089         return;
2090
2091 fail:
2092         log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2093         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2094 }
2095
2096 static void service_enter_running(Service *s, ServiceResult f) {
2097         int main_pid_ok, cgroup_ok;
2098         assert(s);
2099
2100         if (f != SERVICE_SUCCESS)
2101                 s->result = f;
2102
2103         main_pid_ok = main_pid_good(s);
2104         cgroup_ok = cgroup_good(s);
2105
2106         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2107             (s->bus_name_good || s->type != SERVICE_DBUS))
2108                 service_set_state(s, SERVICE_RUNNING);
2109         else if (s->remain_after_exit)
2110                 service_set_state(s, SERVICE_EXITED);
2111         else
2112                 service_enter_stop(s, SERVICE_SUCCESS);
2113 }
2114
2115 static void service_enter_start_post(Service *s) {
2116         int r;
2117         assert(s);
2118
2119         service_unwatch_control_pid(s);
2120
2121         if (s->watchdog_usec > 0)
2122                 service_reset_watchdog(s);
2123
2124         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2125                 s->control_command_id = SERVICE_EXEC_START_POST;
2126
2127                 r = service_spawn(s,
2128                                   s->control_command,
2129                                   true,
2130                                   false,
2131                                   !s->permissions_start_only,
2132                                   !s->root_directory_start_only,
2133                                   false,
2134                                   false,
2135                                   true,
2136                                   &s->control_pid);
2137                 if (r < 0)
2138                         goto fail;
2139
2140                 service_set_state(s, SERVICE_START_POST);
2141         } else
2142                 service_enter_running(s, SERVICE_SUCCESS);
2143
2144         return;
2145
2146 fail:
2147         log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2148         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2149 }
2150
2151 static void service_enter_start(Service *s) {
2152         pid_t pid;
2153         int r;
2154         ExecCommand *c;
2155
2156         assert(s);
2157
2158         assert(s->exec_command[SERVICE_EXEC_START]);
2159         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2160
2161         if (s->type == SERVICE_FORKING)
2162                 service_unwatch_control_pid(s);
2163         else
2164                 service_unwatch_main_pid(s);
2165
2166         /* We want to ensure that nobody leaks processes from
2167          * START_PRE here, so let's go on a killing spree, People
2168          * should not spawn long running processes from START_PRE. */
2169         cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2170
2171         if (s->type == SERVICE_FORKING) {
2172                 s->control_command_id = SERVICE_EXEC_START;
2173                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2174
2175                 s->main_command = NULL;
2176         } else {
2177                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2178                 s->control_command = NULL;
2179
2180                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2181         }
2182
2183         r = service_spawn(s,
2184                           c,
2185                           s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2186                           true,
2187                           true,
2188                           true,
2189                           true,
2190                           s->notify_access != NOTIFY_NONE,
2191                           false,
2192                           &pid);
2193         if (r < 0)
2194                 goto fail;
2195
2196         if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2197                 /* For simple services we immediately start
2198                  * the START_POST binaries. */
2199
2200                 service_set_main_pid(s, pid);
2201                 service_enter_start_post(s);
2202
2203         } else  if (s->type == SERVICE_FORKING) {
2204
2205                 /* For forking services we wait until the start
2206                  * process exited. */
2207
2208                 s->control_pid = pid;
2209                 service_set_state(s, SERVICE_START);
2210
2211         } else if (s->type == SERVICE_ONESHOT ||
2212                    s->type == SERVICE_DBUS ||
2213                    s->type == SERVICE_NOTIFY) {
2214
2215                 /* For oneshot services we wait until the start
2216                  * process exited, too, but it is our main process. */
2217
2218                 /* For D-Bus services we know the main pid right away,
2219                  * but wait for the bus name to appear on the
2220                  * bus. Notify services are similar. */
2221
2222                 service_set_main_pid(s, pid);
2223                 service_set_state(s, SERVICE_START);
2224         } else
2225                 assert_not_reached("Unknown service type");
2226
2227         return;
2228
2229 fail:
2230         log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2231         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2232 }
2233
2234 static void service_enter_start_pre(Service *s) {
2235         int r;
2236
2237         assert(s);
2238
2239         service_unwatch_control_pid(s);
2240
2241         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2242
2243                 /* Before we start anything, let's clear up what might
2244                  * be left from previous runs. */
2245                 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2246
2247                 s->control_command_id = SERVICE_EXEC_START_PRE;
2248
2249                 r = service_spawn(s,
2250                                   s->control_command,
2251                                   true,
2252                                   false,
2253                                   !s->permissions_start_only,
2254                                   !s->root_directory_start_only,
2255                                   true,
2256                                   false,
2257                                   true,
2258                                   &s->control_pid);
2259                 if (r < 0)
2260                         goto fail;
2261
2262                 service_set_state(s, SERVICE_START_PRE);
2263         } else
2264                 service_enter_start(s);
2265
2266         return;
2267
2268 fail:
2269         log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2270         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2271 }
2272
2273 static void service_enter_restart(Service *s) {
2274         int r;
2275         DBusError error;
2276
2277         assert(s);
2278         dbus_error_init(&error);
2279
2280         if (UNIT(s)->job && UNIT(s)->job->type == JOB_STOP) {
2281                 /* Don't restart things if we are going down anyway */
2282                 log_info("Stop job pending for unit, delaying automatic restart.");
2283
2284                 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
2285                 if (r < 0)
2286                         goto fail;
2287
2288                 return;
2289         }
2290
2291         /* Any units that are bound to this service must also be
2292          * restarted. We use JOB_RESTART (instead of the more obvious
2293          * JOB_START) here so that those dependency jobs will be added
2294          * as well. */
2295         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2296         if (r < 0)
2297                 goto fail;
2298
2299         /* Note that we stay in the SERVICE_AUTO_RESTART state here,
2300          * it will be canceled as part of the service_stop() call that
2301          * is executed as part of JOB_RESTART. */
2302
2303         log_debug("%s scheduled restart job.", UNIT(s)->id);
2304         return;
2305
2306 fail:
2307         log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2308         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2309
2310         dbus_error_free(&error);
2311 }
2312
2313 static void service_enter_reload(Service *s) {
2314         int r;
2315
2316         assert(s);
2317
2318         service_unwatch_control_pid(s);
2319
2320         if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2321                 s->control_command_id = SERVICE_EXEC_RELOAD;
2322
2323                 r = service_spawn(s,
2324                                   s->control_command,
2325                                   true,
2326                                   false,
2327                                   !s->permissions_start_only,
2328                                   !s->root_directory_start_only,
2329                                   false,
2330                                   false,
2331                                   true,
2332                                   &s->control_pid);
2333                 if (r < 0)
2334                         goto fail;
2335
2336                 service_set_state(s, SERVICE_RELOAD);
2337         } else
2338                 service_enter_running(s, SERVICE_SUCCESS);
2339
2340         return;
2341
2342 fail:
2343         log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2344         s->reload_result = SERVICE_FAILURE_RESOURCES;
2345         service_enter_running(s, SERVICE_SUCCESS);
2346 }
2347
2348 static void service_run_next_control(Service *s) {
2349         int r;
2350
2351         assert(s);
2352         assert(s->control_command);
2353         assert(s->control_command->command_next);
2354
2355         assert(s->control_command_id != SERVICE_EXEC_START);
2356
2357         s->control_command = s->control_command->command_next;
2358         service_unwatch_control_pid(s);
2359
2360         r = service_spawn(s,
2361                           s->control_command,
2362                           true,
2363                           false,
2364                           !s->permissions_start_only,
2365                           !s->root_directory_start_only,
2366                           s->control_command_id == SERVICE_EXEC_START_PRE ||
2367                           s->control_command_id == SERVICE_EXEC_STOP_POST,
2368                           false,
2369                           true,
2370                           &s->control_pid);
2371         if (r < 0)
2372                 goto fail;
2373
2374         return;
2375
2376 fail:
2377         log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2378
2379         if (s->state == SERVICE_START_PRE)
2380                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2381         else if (s->state == SERVICE_STOP)
2382                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2383         else if (s->state == SERVICE_STOP_POST)
2384                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2385         else if (s->state == SERVICE_RELOAD) {
2386                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2387                 service_enter_running(s, SERVICE_SUCCESS);
2388         } else
2389                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2390 }
2391
2392 static void service_run_next_main(Service *s) {
2393         pid_t pid;
2394         int r;
2395
2396         assert(s);
2397         assert(s->main_command);
2398         assert(s->main_command->command_next);
2399         assert(s->type == SERVICE_ONESHOT);
2400
2401         s->main_command = s->main_command->command_next;
2402         service_unwatch_main_pid(s);
2403
2404         r = service_spawn(s,
2405                           s->main_command,
2406                           true,
2407                           true,
2408                           true,
2409                           true,
2410                           true,
2411                           s->notify_access != NOTIFY_NONE,
2412                           false,
2413                           &pid);
2414         if (r < 0)
2415                 goto fail;
2416
2417         service_set_main_pid(s, pid);
2418
2419         return;
2420
2421 fail:
2422         log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2423         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2424 }
2425
2426 static int service_start_limit_test(Service *s) {
2427         assert(s);
2428
2429         if (ratelimit_test(&s->start_limit))
2430                 return 0;
2431
2432         switch (s->start_limit_action) {
2433
2434         case SERVICE_START_LIMIT_NONE:
2435                 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2436                 break;
2437
2438         case SERVICE_START_LIMIT_REBOOT: {
2439                 DBusError error;
2440                 int r;
2441
2442                 dbus_error_init(&error);
2443
2444                 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2445
2446                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2447                 if (r < 0) {
2448                         log_error("Failed to reboot: %s.", bus_error(&error, r));
2449                         dbus_error_free(&error);
2450                 }
2451
2452                 break;
2453         }
2454
2455         case SERVICE_START_LIMIT_REBOOT_FORCE:
2456                 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2457                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2458                 break;
2459
2460         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2461                 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2462                 reboot(RB_AUTOBOOT);
2463                 break;
2464
2465         default:
2466                 log_error("start limit action=%i", s->start_limit_action);
2467                 assert_not_reached("Unknown StartLimitAction.");
2468         }
2469
2470         return -ECANCELED;
2471 }
2472
2473 static int service_start(Unit *u) {
2474         Service *s = SERVICE(u);
2475         int r;
2476
2477         assert(s);
2478
2479         /* We cannot fulfill this request right now, try again later
2480          * please! */
2481         if (s->state == SERVICE_STOP ||
2482             s->state == SERVICE_STOP_SIGTERM ||
2483             s->state == SERVICE_STOP_SIGKILL ||
2484             s->state == SERVICE_STOP_POST ||
2485             s->state == SERVICE_FINAL_SIGTERM ||
2486             s->state == SERVICE_FINAL_SIGKILL)
2487                 return -EAGAIN;
2488
2489         /* Already on it! */
2490         if (s->state == SERVICE_START_PRE ||
2491             s->state == SERVICE_START ||
2492             s->state == SERVICE_START_POST)
2493                 return 0;
2494
2495         /* A service that will be restarted must be stopped first to
2496          * trigger BindsTo and/or OnFailure dependencies. If a user
2497          * does not want to wait for the holdoff time to elapse, the
2498          * service should be manually restarted, not started. We
2499          * simply return EAGAIN here, so that any start jobs stay
2500          * queued, and assume that the auto restart timer will
2501          * eventually trigger the restart. */
2502         if (s->state == SERVICE_AUTO_RESTART)
2503                 return -EAGAIN;
2504
2505         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2506
2507         /* Make sure we don't enter a busy loop of some kind. */
2508         r = service_start_limit_test(s);
2509         if (r < 0) {
2510                 service_enter_dead(s, SERVICE_FAILURE_START_LIMIT, false);
2511                 return r;
2512         }
2513
2514         s->result = SERVICE_SUCCESS;
2515         s->reload_result = SERVICE_SUCCESS;
2516         s->main_pid_known = false;
2517         s->main_pid_alien = false;
2518         s->forbid_restart = false;
2519
2520         service_enter_start_pre(s);
2521         return 0;
2522 }
2523
2524 static int service_stop(Unit *u) {
2525         Service *s = SERVICE(u);
2526
2527         assert(s);
2528
2529         /* Don't create restart jobs from here. */
2530         s->forbid_restart = true;
2531
2532         /* Already on it */
2533         if (s->state == SERVICE_STOP ||
2534             s->state == SERVICE_STOP_SIGTERM ||
2535             s->state == SERVICE_STOP_SIGKILL ||
2536             s->state == SERVICE_STOP_POST ||
2537             s->state == SERVICE_FINAL_SIGTERM ||
2538             s->state == SERVICE_FINAL_SIGKILL)
2539                 return 0;
2540
2541         /* A restart will be scheduled or is in progress. */
2542         if (s->state == SERVICE_AUTO_RESTART) {
2543                 service_set_state(s, SERVICE_DEAD);
2544                 return 0;
2545         }
2546
2547         /* If there's already something running we go directly into
2548          * kill mode. */
2549         if (s->state == SERVICE_START_PRE ||
2550             s->state == SERVICE_START ||
2551             s->state == SERVICE_START_POST ||
2552             s->state == SERVICE_RELOAD) {
2553                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2554                 return 0;
2555         }
2556
2557         assert(s->state == SERVICE_RUNNING ||
2558                s->state == SERVICE_EXITED);
2559
2560         service_enter_stop(s, SERVICE_SUCCESS);
2561         return 0;
2562 }
2563
2564 static int service_reload(Unit *u) {
2565         Service *s = SERVICE(u);
2566
2567         assert(s);
2568
2569         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2570
2571         service_enter_reload(s);
2572         return 0;
2573 }
2574
2575 static bool service_can_reload(Unit *u) {
2576         Service *s = SERVICE(u);
2577
2578         assert(s);
2579
2580         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2581 }
2582
2583 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2584         Service *s = SERVICE(u);
2585
2586         assert(u);
2587         assert(f);
2588         assert(fds);
2589
2590         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2591         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2592         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2593
2594         if (s->control_pid > 0)
2595                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2596
2597         if (s->main_pid_known && s->main_pid > 0)
2598                 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2599
2600         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2601
2602         if (s->status_text)
2603                 unit_serialize_item(u, f, "status-text", s->status_text);
2604
2605         /* FIXME: There's a minor uncleanliness here: if there are
2606          * multiple commands attached here, we will start from the
2607          * first one again */
2608         if (s->control_command_id >= 0)
2609                 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2610
2611         if (s->socket_fd >= 0) {
2612                 int copy;
2613
2614                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2615                         return copy;
2616
2617                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2618         }
2619
2620         if (s->main_exec_status.pid > 0) {
2621                 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2622                 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2623                 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2624
2625                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2626                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2627                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2628                 }
2629         }
2630         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2631                 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2632
2633         return 0;
2634 }
2635
2636 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2637         Service *s = SERVICE(u);
2638
2639         assert(u);
2640         assert(key);
2641         assert(value);
2642         assert(fds);
2643
2644         if (streq(key, "state")) {
2645                 ServiceState state;
2646
2647                 if ((state = service_state_from_string(value)) < 0)
2648                         log_debug("Failed to parse state value %s", value);
2649                 else
2650                         s->deserialized_state = state;
2651         } else if (streq(key, "result")) {
2652                 ServiceResult f;
2653
2654                 f = service_result_from_string(value);
2655                 if (f < 0)
2656                         log_debug("Failed to parse result value %s", value);
2657                 else if (f != SERVICE_SUCCESS)
2658                         s->result = f;
2659
2660         } else if (streq(key, "reload-result")) {
2661                 ServiceResult f;
2662
2663                 f = service_result_from_string(value);
2664                 if (f < 0)
2665                         log_debug("Failed to parse reload result value %s", value);
2666                 else if (f != SERVICE_SUCCESS)
2667                         s->reload_result = f;
2668
2669         } else if (streq(key, "control-pid")) {
2670                 pid_t pid;
2671
2672                 if (parse_pid(value, &pid) < 0)
2673                         log_debug("Failed to parse control-pid value %s", value);
2674                 else
2675                         s->control_pid = pid;
2676         } else if (streq(key, "main-pid")) {
2677                 pid_t pid;
2678
2679                 if (parse_pid(value, &pid) < 0)
2680                         log_debug("Failed to parse main-pid value %s", value);
2681                 else
2682                         service_set_main_pid(s, (pid_t) pid);
2683         } else if (streq(key, "main-pid-known")) {
2684                 int b;
2685
2686                 if ((b = parse_boolean(value)) < 0)
2687                         log_debug("Failed to parse main-pid-known value %s", value);
2688                 else
2689                         s->main_pid_known = b;
2690         } else if (streq(key, "status-text")) {
2691                 char *t;
2692
2693                 if ((t = strdup(value))) {
2694                         free(s->status_text);
2695                         s->status_text = t;
2696                 }
2697
2698         } else if (streq(key, "control-command")) {
2699                 ServiceExecCommand id;
2700
2701                 if ((id = service_exec_command_from_string(value)) < 0)
2702                         log_debug("Failed to parse exec-command value %s", value);
2703                 else {
2704                         s->control_command_id = id;
2705                         s->control_command = s->exec_command[id];
2706                 }
2707         } else if (streq(key, "socket-fd")) {
2708                 int fd;
2709
2710                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2711                         log_debug("Failed to parse socket-fd value %s", value);
2712                 else {
2713
2714                         if (s->socket_fd >= 0)
2715                                 close_nointr_nofail(s->socket_fd);
2716                         s->socket_fd = fdset_remove(fds, fd);
2717                 }
2718         } else if (streq(key, "main-exec-status-pid")) {
2719                 pid_t pid;
2720
2721                 if (parse_pid(value, &pid) < 0)
2722                         log_debug("Failed to parse main-exec-status-pid value %s", value);
2723                 else
2724                         s->main_exec_status.pid = pid;
2725         } else if (streq(key, "main-exec-status-code")) {
2726                 int i;
2727
2728                 if (safe_atoi(value, &i) < 0)
2729                         log_debug("Failed to parse main-exec-status-code value %s", value);
2730                 else
2731                         s->main_exec_status.code = i;
2732         } else if (streq(key, "main-exec-status-status")) {
2733                 int i;
2734
2735                 if (safe_atoi(value, &i) < 0)
2736                         log_debug("Failed to parse main-exec-status-status value %s", value);
2737                 else
2738                         s->main_exec_status.status = i;
2739         } else if (streq(key, "main-exec-status-start"))
2740                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2741         else if (streq(key, "main-exec-status-exit"))
2742                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2743         else if (streq(key, "watchdog-timestamp"))
2744                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2745         else
2746                 log_debug("Unknown serialization key '%s'", key);
2747
2748         return 0;
2749 }
2750
2751 static UnitActiveState service_active_state(Unit *u) {
2752         const UnitActiveState *table;
2753
2754         assert(u);
2755
2756         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2757
2758         return table[SERVICE(u)->state];
2759 }
2760
2761 static const char *service_sub_state_to_string(Unit *u) {
2762         assert(u);
2763
2764         return service_state_to_string(SERVICE(u)->state);
2765 }
2766
2767 static bool service_check_gc(Unit *u) {
2768         Service *s = SERVICE(u);
2769
2770         assert(s);
2771
2772         /* Never clean up services that still have a process around,
2773          * even if the service is formally dead. */
2774         if (cgroup_good(s) > 0 ||
2775             main_pid_good(s) > 0 ||
2776             control_pid_good(s) > 0)
2777                 return true;
2778
2779 #ifdef HAVE_SYSV_COMPAT
2780         if (s->is_sysv)
2781                 return true;
2782 #endif
2783
2784         return false;
2785 }
2786
2787 static bool service_check_snapshot(Unit *u) {
2788         Service *s = SERVICE(u);
2789
2790         assert(s);
2791
2792         return !s->got_socket_fd;
2793 }
2794
2795 static int service_retry_pid_file(Service *s) {
2796         int r;
2797
2798         assert(s->pid_file);
2799         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2800
2801         r = service_load_pid_file(s, false);
2802         if (r < 0)
2803                 return r;
2804
2805         service_unwatch_pid_file(s);
2806
2807         service_enter_running(s, SERVICE_SUCCESS);
2808         return 0;
2809 }
2810
2811 static int service_watch_pid_file(Service *s) {
2812         int r;
2813
2814         log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2815         r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2816         if (r < 0)
2817                 goto fail;
2818
2819         /* the pidfile might have appeared just before we set the watch */
2820         service_retry_pid_file(s);
2821
2822         return 0;
2823 fail:
2824         log_error("Failed to set a watch for %s's PID file %s: %s",
2825                   UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2826         service_unwatch_pid_file(s);
2827         return r;
2828 }
2829
2830 static int service_demand_pid_file(Service *s) {
2831         PathSpec *ps;
2832
2833         assert(s->pid_file);
2834         assert(!s->pid_file_pathspec);
2835
2836         ps = new0(PathSpec, 1);
2837         if (!ps)
2838                 return -ENOMEM;
2839
2840         ps->path = strdup(s->pid_file);
2841         if (!ps->path) {
2842                 free(ps);
2843                 return -ENOMEM;
2844         }
2845
2846         path_kill_slashes(ps->path);
2847
2848         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2849          * keep their PID file open all the time. */
2850         ps->type = PATH_MODIFIED;
2851         ps->inotify_fd = -1;
2852
2853         s->pid_file_pathspec = ps;
2854
2855         return service_watch_pid_file(s);
2856 }
2857
2858 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2859         Service *s = SERVICE(u);
2860
2861         assert(s);
2862         assert(fd >= 0);
2863         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2864         assert(s->pid_file_pathspec);
2865         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2866
2867         log_debug("inotify event for %s", u->id);
2868
2869         if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2870                 goto fail;
2871
2872         if (service_retry_pid_file(s) == 0)
2873                 return;
2874
2875         if (service_watch_pid_file(s) < 0)
2876                 goto fail;
2877
2878         return;
2879 fail:
2880         service_unwatch_pid_file(s);
2881         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2882 }
2883
2884 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2885         Service *s = SERVICE(u);
2886         ServiceResult f;
2887
2888         assert(s);
2889         assert(pid >= 0);
2890
2891         if (UNIT(s)->fragment_path ? is_clean_exit(code, status, &s->success_status) :
2892                                      is_clean_exit_lsb(code, status, &s->success_status))
2893                 f = SERVICE_SUCCESS;
2894         else if (code == CLD_EXITED)
2895                 f = SERVICE_FAILURE_EXIT_CODE;
2896         else if (code == CLD_KILLED)
2897                 f = SERVICE_FAILURE_SIGNAL;
2898         else if (code == CLD_DUMPED)
2899                 f = SERVICE_FAILURE_CORE_DUMP;
2900         else
2901                 assert_not_reached("Unknown code");
2902
2903         if (s->main_pid == pid) {
2904                 /* Forking services may occasionally move to a new PID.
2905                  * As long as they update the PID file before exiting the old
2906                  * PID, they're fine. */
2907                 if (service_load_pid_file(s, false) == 0)
2908                         return;
2909
2910                 s->main_pid = 0;
2911                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2912
2913                 /* If this is not a forking service than the main
2914                  * process got started and hence we copy the exit
2915                  * status so that it is recorded both as main and as
2916                  * control process exit status */
2917                 if (s->main_command) {
2918                         s->main_command->exec_status = s->main_exec_status;
2919
2920                         if (s->main_command->ignore)
2921                                 f = SERVICE_SUCCESS;
2922                 }
2923
2924                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2925                          "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2926
2927                 if (f != SERVICE_SUCCESS)
2928                         s->result = f;
2929
2930                 if (s->main_command &&
2931                     s->main_command->command_next &&
2932                     f == SERVICE_SUCCESS) {
2933
2934                         /* There is another command to *
2935                          * execute, so let's do that. */
2936
2937                         log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2938                         service_run_next_main(s);
2939
2940                 } else {
2941
2942                         /* The service exited, so the service is officially
2943                          * gone. */
2944                         s->main_command = NULL;
2945
2946                         switch (s->state) {
2947
2948                         case SERVICE_START_POST:
2949                         case SERVICE_RELOAD:
2950                         case SERVICE_STOP:
2951                                 /* Need to wait until the operation is
2952                                  * done */
2953                                 break;
2954
2955                         case SERVICE_START:
2956                                 if (s->type == SERVICE_ONESHOT) {
2957                                         /* This was our main goal, so let's go on */
2958                                         if (f == SERVICE_SUCCESS)
2959                                                 service_enter_start_post(s);
2960                                         else
2961                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2962                                         break;
2963                                 }
2964
2965                                 /* Fall through */
2966
2967                         case SERVICE_RUNNING:
2968                                 service_enter_running(s, f);
2969                                 break;
2970
2971                         case SERVICE_STOP_SIGTERM:
2972                         case SERVICE_STOP_SIGKILL:
2973
2974                                 if (!control_pid_good(s))
2975                                         service_enter_stop_post(s, f);
2976
2977                                 /* If there is still a control process, wait for that first */
2978                                 break;
2979
2980                         default:
2981                                 assert_not_reached("Uh, main process died at wrong time.");
2982                         }
2983                 }
2984
2985         } else if (s->control_pid == pid) {
2986
2987                 s->control_pid = 0;
2988
2989                 if (s->control_command) {
2990                         exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2991
2992                         if (s->control_command->ignore)
2993                                 f = SERVICE_SUCCESS;
2994                 }
2995
2996                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2997                          "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2998
2999                 if (f != SERVICE_SUCCESS)
3000                         s->result = f;
3001
3002                 /* Immediately get rid of the cgroup, so that the
3003                  * kernel doesn't delay the cgroup empty messages for
3004                  * the service cgroup any longer than necessary */
3005                 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
3006
3007                 if (s->control_command &&
3008                     s->control_command->command_next &&
3009                     f == SERVICE_SUCCESS) {
3010
3011                         /* There is another command to *
3012                          * execute, so let's do that. */
3013
3014                         log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
3015                         service_run_next_control(s);
3016
3017                 } else {
3018                         /* No further commands for this step, so let's
3019                          * figure out what to do next */
3020
3021                         s->control_command = NULL;
3022                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
3023
3024                         log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
3025
3026                         switch (s->state) {
3027
3028                         case SERVICE_START_PRE:
3029                                 if (f == SERVICE_SUCCESS)
3030                                         service_enter_start(s);
3031                                 else
3032                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3033                                 break;
3034
3035                         case SERVICE_START:
3036                                 if (s->type != SERVICE_FORKING)
3037                                         /* Maybe spurious event due to a reload that changed the type? */
3038                                         break;
3039
3040                                 if (f != SERVICE_SUCCESS) {
3041                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3042                                         break;
3043                                 }
3044
3045                                 if (s->pid_file) {
3046                                         bool has_start_post;
3047                                         int r;
3048
3049                                         /* Let's try to load the pid file here if we can.
3050                                          * The PID file might actually be created by a START_POST
3051                                          * script. In that case don't worry if the loading fails. */
3052
3053                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3054                                         r = service_load_pid_file(s, !has_start_post);
3055                                         if (!has_start_post && r < 0) {
3056                                                 r = service_demand_pid_file(s);
3057                                                 if (r < 0 || !cgroup_good(s))
3058                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3059                                                 break;
3060                                         }
3061                                 } else
3062                                         service_search_main_pid(s);
3063
3064                                 service_enter_start_post(s);
3065                                 break;
3066
3067                         case SERVICE_START_POST:
3068                                 if (f != SERVICE_SUCCESS) {
3069                                         service_enter_stop(s, f);
3070                                         break;
3071                                 }
3072
3073                                 if (s->pid_file) {
3074                                         int r;
3075
3076                                         r = service_load_pid_file(s, true);
3077                                         if (r < 0) {
3078                                                 r = service_demand_pid_file(s);
3079                                                 if (r < 0 || !cgroup_good(s))
3080                                                         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3081                                                 break;
3082                                         }
3083                                 } else
3084                                         service_search_main_pid(s);
3085
3086                                 service_enter_running(s, SERVICE_SUCCESS);
3087                                 break;
3088
3089                         case SERVICE_RELOAD:
3090                                 if (f == SERVICE_SUCCESS) {
3091                                         service_load_pid_file(s, true);
3092                                         service_search_main_pid(s);
3093                                 }
3094
3095                                 s->reload_result = f;
3096                                 service_enter_running(s, SERVICE_SUCCESS);
3097                                 break;
3098
3099                         case SERVICE_STOP:
3100                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3101                                 break;
3102
3103                         case SERVICE_STOP_SIGTERM:
3104                         case SERVICE_STOP_SIGKILL:
3105                                 if (main_pid_good(s) <= 0)
3106                                         service_enter_stop_post(s, f);
3107
3108                                 /* If there is still a service
3109                                  * process around, wait until
3110                                  * that one quit, too */
3111                                 break;
3112
3113                         case SERVICE_STOP_POST:
3114                         case SERVICE_FINAL_SIGTERM:
3115                         case SERVICE_FINAL_SIGKILL:
3116                                 service_enter_dead(s, f, true);
3117                                 break;
3118
3119                         default:
3120                                 assert_not_reached("Uh, control process died at wrong time.");
3121                         }
3122                 }
3123         }
3124
3125         /* Notify clients about changed exit status */
3126         unit_add_to_dbus_queue(u);
3127 }
3128
3129 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3130         Service *s = SERVICE(u);
3131
3132         assert(s);
3133         assert(elapsed == 1);
3134
3135         if (w == &s->watchdog_watch) {
3136                 service_handle_watchdog(s);
3137                 return;
3138         }
3139
3140         assert(w == &s->timer_watch);
3141
3142         switch (s->state) {
3143
3144         case SERVICE_START_PRE:
3145         case SERVICE_START:
3146                 log_warning("%s operation timed out. Terminating.", u->id);
3147                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3148                 break;
3149
3150         case SERVICE_START_POST:
3151                 log_warning("%s operation timed out. Stopping.", u->id);
3152                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3153                 break;
3154
3155         case SERVICE_RELOAD:
3156                 log_warning("%s operation timed out. Stopping.", u->id);
3157                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3158                 service_enter_running(s, SERVICE_SUCCESS);
3159                 break;
3160
3161         case SERVICE_STOP:
3162                 log_warning("%s stopping timed out. Terminating.", u->id);
3163                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3164                 break;
3165
3166         case SERVICE_STOP_SIGTERM:
3167                 if (s->kill_context.send_sigkill) {
3168                         log_warning("%s stopping timed out. Killing.", u->id);
3169                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3170                 } else {
3171                         log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3172                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3173                 }
3174
3175                 break;
3176
3177         case SERVICE_STOP_SIGKILL:
3178                 /* Uh, we sent a SIGKILL and it is still not gone?
3179                  * Must be something we cannot kill, so let's just be
3180                  * weirded out and continue */
3181
3182                 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3183                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3184                 break;
3185
3186         case SERVICE_STOP_POST:
3187                 log_warning("%s stopping timed out (2). Terminating.", u->id);
3188                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3189                 break;
3190
3191         case SERVICE_FINAL_SIGTERM:
3192                 if (s->kill_context.send_sigkill) {
3193                         log_warning("%s stopping timed out (2). Killing.", u->id);
3194                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3195                 } else {
3196                         log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3197                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3198                 }
3199
3200                 break;
3201
3202         case SERVICE_FINAL_SIGKILL:
3203                 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3204                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3205                 break;
3206
3207         case SERVICE_AUTO_RESTART:
3208                 log_info("%s holdoff time over, scheduling restart.", u->id);
3209                 service_enter_restart(s);
3210                 break;
3211
3212         default:
3213                 assert_not_reached("Timeout at wrong time.");
3214         }
3215 }
3216
3217 static void service_cgroup_notify_event(Unit *u) {
3218         Service *s = SERVICE(u);
3219
3220         assert(u);
3221
3222         log_debug("%s: cgroup is empty", u->id);
3223
3224         switch (s->state) {
3225
3226                 /* Waiting for SIGCHLD is usually more interesting,
3227                  * because it includes return codes/signals. Which is
3228                  * why we ignore the cgroup events for most cases,
3229                  * except when we don't know pid which to expect the
3230                  * SIGCHLD for. */
3231
3232         case SERVICE_START:
3233         case SERVICE_START_POST:
3234                 /* If we were hoping for the daemon to write its PID file,
3235                  * we can give up now. */
3236                 if (s->pid_file_pathspec) {
3237                         log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3238                         service_unwatch_pid_file(s);
3239                         if (s->state == SERVICE_START)
3240                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3241                         else
3242                                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3243                 }
3244                 break;
3245
3246         case SERVICE_RUNNING:
3247                 /* service_enter_running() will figure out what to do */
3248                 service_enter_running(s, SERVICE_SUCCESS);
3249                 break;
3250
3251         case SERVICE_STOP_SIGTERM:
3252         case SERVICE_STOP_SIGKILL:
3253
3254                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3255                         service_enter_stop_post(s, SERVICE_SUCCESS);
3256
3257                 break;
3258
3259         case SERVICE_FINAL_SIGTERM:
3260         case SERVICE_FINAL_SIGKILL:
3261                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3262                         service_enter_dead(s, SERVICE_SUCCESS, true);
3263
3264                 break;
3265
3266         default:
3267                 ;
3268         }
3269 }
3270
3271 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3272         Service *s = SERVICE(u);
3273         const char *e;
3274
3275         assert(u);
3276
3277         if (s->notify_access == NOTIFY_NONE) {
3278                 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3279                             u->id, (unsigned long) pid);
3280                 return;
3281         }
3282
3283         if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3284                 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3285                             u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3286                 return;
3287         }
3288
3289         log_debug("%s: Got message", u->id);
3290
3291         /* Interpret MAINPID= */
3292         if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3293             (s->state == SERVICE_START ||
3294              s->state == SERVICE_START_POST ||
3295              s->state == SERVICE_RUNNING ||
3296              s->state == SERVICE_RELOAD)) {
3297
3298                 if (parse_pid(e + 8, &pid) < 0)
3299                         log_warning("Failed to parse notification message %s", e);
3300                 else {
3301                         log_debug("%s: got %s", u->id, e);
3302                         service_set_main_pid(s, pid);
3303                 }
3304         }
3305
3306         /* Interpret READY= */
3307         if (s->type == SERVICE_NOTIFY &&
3308             s->state == SERVICE_START &&
3309             strv_find(tags, "READY=1")) {
3310                 log_debug("%s: got READY=1", u->id);
3311
3312                 service_enter_start_post(s);
3313         }
3314
3315         /* Interpret STATUS= */
3316         e = strv_find_prefix(tags, "STATUS=");
3317         if (e) {
3318                 char *t;
3319
3320                 if (e[7]) {
3321
3322                         if (!utf8_is_valid(e+7)) {
3323                                 log_warning("Status message in notification is not UTF-8 clean.");
3324                                 return;
3325                         }
3326
3327                         t = strdup(e+7);
3328                         if (!t) {
3329                                 log_error("Failed to allocate string.");
3330                                 return;
3331                         }
3332
3333                         log_debug("%s: got %s", u->id, e);
3334
3335                         free(s->status_text);
3336                         s->status_text = t;
3337                 } else {
3338                         free(s->status_text);
3339                         s->status_text = NULL;
3340                 }
3341
3342         }
3343         if (strv_find(tags, "WATCHDOG=1")) {
3344                 log_debug("%s: got WATCHDOG=1", u->id);
3345                 service_reset_watchdog(s);
3346         }
3347
3348         /* Notify clients about changed status or main pid */
3349         unit_add_to_dbus_queue(u);
3350 }
3351
3352 #ifdef HAVE_SYSV_COMPAT
3353
3354 #ifdef TARGET_SUSE
3355 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3356         FILE *f=NULL;
3357         int r;
3358
3359         if (!(f = fopen("/etc/insserv.conf", "re"))) {
3360                 r = errno == ENOENT ? 0 : -errno;
3361                 goto finish;
3362         }
3363
3364         while (!feof(f)) {
3365                 char l[LINE_MAX], *t;
3366                 char **parsed = NULL;
3367
3368                 if (!fgets(l, sizeof(l), f)) {
3369                         if (feof(f))
3370                                 break;
3371
3372                         r = -errno;
3373                         log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3374                         goto finish;
3375                 }
3376
3377                 t = strstrip(l);
3378                 if (*t != '$' && *t != '<')
3379                         continue;
3380
3381                 parsed = strv_split(t,WHITESPACE);
3382                 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3383                 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3384                         char *facility;
3385                         Unit *u;
3386                         if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3387                                 continue;
3388                         if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3389                                 UnitDependency e;
3390                                 char *dep = NULL, *name, **j;
3391
3392                                 STRV_FOREACH (j, parsed+1) {
3393                                         if (*j[0]=='+') {
3394                                                 e = UNIT_WANTS;
3395                                                 name = *j+1;
3396                                         }
3397                                         else {
3398                                                 e = UNIT_REQUIRES;
3399                                                 name = *j;
3400                                         }
3401                                         if (sysv_translate_facility(name, NULL, &dep) < 0)
3402                                                 continue;
3403
3404                                         r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3405                                         free(dep);
3406                                 }
3407                         }
3408                         free(facility);
3409                 }
3410                 strv_free(parsed);
3411         }
3412 finish:
3413         if (f)
3414                 fclose(f);
3415
3416 }
3417 #endif
3418
3419 static int service_enumerate(Manager *m) {
3420         char **p;
3421         unsigned i;
3422         DIR *d = NULL;
3423         char *path = NULL, *fpath = NULL, *name = NULL;
3424         Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3425         Unit *service;
3426         Iterator j;
3427         int r;
3428
3429         assert(m);
3430
3431         if (m->running_as != SYSTEMD_SYSTEM)
3432                 return 0;
3433
3434         zero(runlevel_services);
3435
3436         STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3437                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3438                         struct dirent *de;
3439
3440                         free(path);
3441                         path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3442                         if (!path) {
3443                                 r = -ENOMEM;
3444                                 goto finish;
3445                         }
3446
3447                         if (d)
3448                                 closedir(d);
3449
3450                         if (!(d = opendir(path))) {
3451                                 if (errno != ENOENT)
3452                                         log_warning("opendir() failed on %s: %s", path, strerror(errno));
3453
3454                                 continue;
3455                         }
3456
3457                         while ((de = readdir(d))) {
3458                                 int a, b;
3459
3460                                 if (ignore_file(de->d_name))
3461                                         continue;
3462
3463                                 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3464                                         continue;
3465
3466                                 if (strlen(de->d_name) < 4)
3467                                         continue;
3468
3469                                 a = undecchar(de->d_name[1]);
3470                                 b = undecchar(de->d_name[2]);
3471
3472                                 if (a < 0 || b < 0)
3473                                         continue;
3474
3475                                 free(fpath);
3476                                 fpath = strjoin(path, "/", de->d_name, NULL);
3477                                 if (!fpath) {
3478                                         r = -ENOMEM;
3479                                         goto finish;
3480                                 }
3481
3482                                 if (access(fpath, X_OK) < 0) {
3483
3484                                         if (errno != ENOENT)
3485                                                 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3486
3487                                         continue;
3488                                 }
3489
3490                                 free(name);
3491                                 if (!(name = sysv_translate_name(de->d_name + 3))) {
3492                                         r = -ENOMEM;
3493                                         goto finish;
3494                                 }
3495
3496                                 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3497                                         log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3498                                         continue;
3499                                 }
3500
3501                                 if (de->d_name[0] == 'S')  {
3502
3503                                         if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3504                                                 SERVICE(service)->sysv_start_priority_from_rcnd =
3505                                                         MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3506
3507                                                 SERVICE(service)->sysv_enabled = true;
3508                                         }
3509
3510                                         if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3511                                                 goto finish;
3512
3513                                         if ((r = set_put(runlevel_services[i], service)) < 0)
3514                                                 goto finish;
3515
3516                                 } else if (de->d_name[0] == 'K' &&
3517                                            (rcnd_table[i].type == RUNLEVEL_DOWN ||
3518                                             rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3519
3520                                         if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3521                                                 goto finish;
3522
3523                                         if ((r = set_put(shutdown_services, service)) < 0)
3524                                                 goto finish;
3525                                 }
3526                         }
3527                 }
3528
3529         /* Now we loaded all stubs and are aware of the lowest
3530         start-up priority for all services, not let's actually load
3531         the services, this will also tell us which services are
3532         actually native now */
3533         manager_dispatch_load_queue(m);
3534
3535         /* If this is a native service, rely on native ways to pull in
3536          * a service, don't pull it in via sysv rcN.d links. */
3537         for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3538                 SET_FOREACH(service, runlevel_services[i], j) {
3539                         service = unit_follow_merge(service);
3540
3541                         if (service->fragment_path)
3542                                 continue;
3543
3544                         if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3545                                 goto finish;
3546                 }
3547
3548         /* We honour K links only for halt/reboot. For the normal
3549          * runlevels we assume the stop jobs will be implicitly added
3550          * by the core logic. Also, we don't really distinguish here
3551          * between the runlevels 0 and 6 and just add them to the
3552          * special shutdown target. On SUSE the boot.d/ runlevel is
3553          * also used for shutdown, so we add links for that too to the
3554          * shutdown target.*/
3555         SET_FOREACH(service, shutdown_services, j) {
3556                 service = unit_follow_merge(service);
3557
3558                 if (service->fragment_path)
3559                         continue;
3560
3561                 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3562                         goto finish;
3563         }
3564
3565         r = 0;
3566
3567 #ifdef TARGET_SUSE
3568         sysv_facility_in_insserv_conf (m);
3569 #endif
3570
3571 finish:
3572         free(path);
3573         free(fpath);
3574         free(name);
3575
3576         for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3577                 set_free(runlevel_services[i]);
3578         set_free(shutdown_services);
3579
3580         if (d)
3581                 closedir(d);
3582
3583         return r;
3584 }
3585 #endif
3586
3587 static void service_bus_name_owner_change(
3588                 Unit *u,
3589                 const char *name,
3590                 const char *old_owner,
3591                 const char *new_owner) {
3592
3593         Service *s = SERVICE(u);
3594
3595         assert(s);
3596         assert(name);
3597
3598         assert(streq(s->bus_name, name));
3599         assert(old_owner || new_owner);
3600
3601         if (old_owner && new_owner)
3602                 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3603         else if (old_owner)
3604                 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3605         else
3606                 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3607
3608         s->bus_name_good = !!new_owner;
3609
3610         if (s->type == SERVICE_DBUS) {
3611
3612                 /* service_enter_running() will figure out what to
3613                  * do */
3614                 if (s->state == SERVICE_RUNNING)
3615                         service_enter_running(s, SERVICE_SUCCESS);
3616                 else if (s->state == SERVICE_START && new_owner)
3617                         service_enter_start_post(s);
3618
3619         } else if (new_owner &&
3620                    s->main_pid <= 0 &&
3621                    (s->state == SERVICE_START ||
3622                     s->state == SERVICE_START_POST ||
3623                     s->state == SERVICE_RUNNING ||
3624                     s->state == SERVICE_RELOAD)) {
3625
3626                 /* Try to acquire PID from bus service */
3627                 log_debug("Trying to acquire PID from D-Bus name...");
3628
3629                 bus_query_pid(u->manager, name);
3630         }
3631 }
3632
3633 static void service_bus_query_pid_done(
3634                 Unit *u,
3635                 const char *name,
3636                 pid_t pid) {
3637
3638         Service *s = SERVICE(u);
3639
3640         assert(s);
3641         assert(name);
3642
3643         log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3644
3645         if (s->main_pid <= 0 &&
3646             (s->state == SERVICE_START ||
3647              s->state == SERVICE_START_POST ||
3648              s->state == SERVICE_RUNNING ||
3649              s->state == SERVICE_RELOAD))
3650                 service_set_main_pid(s, pid);
3651 }
3652
3653 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3654
3655         assert(s);
3656         assert(fd >= 0);
3657
3658         /* This is called by the socket code when instantiating a new
3659          * service for a stream socket and the socket needs to be
3660          * configured. */
3661
3662         if (UNIT(s)->load_state != UNIT_LOADED)
3663                 return -EINVAL;
3664
3665         if (s->socket_fd >= 0)
3666                 return -EBUSY;
3667
3668         if (s->state != SERVICE_DEAD)
3669                 return -EAGAIN;
3670
3671         s->socket_fd = fd;
3672         s->got_socket_fd = true;
3673
3674         unit_ref_set(&s->accept_socket, UNIT(sock));
3675
3676         return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3677 }
3678
3679 static void service_reset_failed(Unit *u) {
3680         Service *s = SERVICE(u);
3681
3682         assert(s);
3683
3684         if (s->state == SERVICE_FAILED)
3685                 service_set_state(s, SERVICE_DEAD);
3686
3687         s->result = SERVICE_SUCCESS;
3688         s->reload_result = SERVICE_SUCCESS;
3689
3690         RATELIMIT_RESET(s->start_limit);
3691 }
3692
3693 static int service_kill(Unit *u, KillWho who, int signo, DBusError *error) {
3694         Service *s = SERVICE(u);
3695         int r = 0;
3696         Set *pid_set = NULL;
3697
3698         assert(s);
3699
3700         if (s->main_pid <= 0 && who == KILL_MAIN) {
3701                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3702                 return -ESRCH;
3703         }
3704
3705         if (s->control_pid <= 0 && who == KILL_CONTROL) {
3706                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3707                 return -ESRCH;
3708         }
3709
3710         if (who == KILL_CONTROL || who == KILL_ALL)
3711                 if (s->control_pid > 0)
3712                         if (kill(s->control_pid, signo) < 0)
3713                                 r = -errno;
3714
3715         if (who == KILL_MAIN || who == KILL_ALL)
3716                 if (s->main_pid > 0)
3717                         if (kill(s->main_pid, signo) < 0)
3718                                 r = -errno;
3719
3720         if (who == KILL_ALL) {
3721                 int q;
3722
3723                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
3724                 if (!pid_set)
3725                         return -ENOMEM;
3726
3727                 /* Exclude the control/main pid from being killed via the cgroup */
3728                 if (s->control_pid > 0) {
3729                         q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
3730                         if (q < 0) {
3731                                 r = q;
3732                                 goto finish;
3733                         }
3734                 }
3735
3736                 if (s->main_pid > 0) {
3737                         q = set_put(pid_set, LONG_TO_PTR(s->main_pid));
3738                         if (q < 0) {
3739                                 r = q;
3740                                 goto finish;
3741                         }
3742                 }
3743
3744                 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
3745                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3746                         r = q;
3747         }
3748
3749 finish:
3750         if (pid_set)
3751                 set_free(pid_set);
3752
3753         return r;
3754 }
3755
3756 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3757         [SERVICE_DEAD] = "dead",
3758         [SERVICE_START_PRE] = "start-pre",
3759         [SERVICE_START] = "start",
3760         [SERVICE_START_POST] = "start-post",
3761         [SERVICE_RUNNING] = "running",
3762         [SERVICE_EXITED] = "exited",
3763         [SERVICE_RELOAD] = "reload",
3764         [SERVICE_STOP] = "stop",
3765         [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3766         [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3767         [SERVICE_STOP_POST] = "stop-post",
3768         [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3769         [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3770         [SERVICE_FAILED] = "failed",
3771         [SERVICE_AUTO_RESTART] = "auto-restart",
3772 };
3773
3774 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3775
3776 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3777         [SERVICE_RESTART_NO] = "no",
3778         [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3779         [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3780         [SERVICE_RESTART_ON_ABORT] = "on-abort",
3781         [SERVICE_RESTART_ALWAYS] = "always"
3782 };
3783
3784 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3785
3786 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3787         [SERVICE_SIMPLE] = "simple",
3788         [SERVICE_FORKING] = "forking",
3789         [SERVICE_ONESHOT] = "oneshot",
3790         [SERVICE_DBUS] = "dbus",
3791         [SERVICE_NOTIFY] = "notify",
3792         [SERVICE_IDLE] = "idle"
3793 };
3794
3795 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3796
3797 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3798         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3799         [SERVICE_EXEC_START] = "ExecStart",
3800         [SERVICE_EXEC_START_POST] = "ExecStartPost",
3801         [SERVICE_EXEC_RELOAD] = "ExecReload",
3802         [SERVICE_EXEC_STOP] = "ExecStop",
3803         [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3804 };
3805
3806 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3807
3808 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3809         [NOTIFY_NONE] = "none",
3810         [NOTIFY_MAIN] = "main",
3811         [NOTIFY_ALL] = "all"
3812 };
3813
3814 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3815
3816 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3817         [SERVICE_SUCCESS] = "success",
3818         [SERVICE_FAILURE_RESOURCES] = "resources",
3819         [SERVICE_FAILURE_TIMEOUT] = "timeout",
3820         [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3821         [SERVICE_FAILURE_SIGNAL] = "signal",
3822         [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3823         [SERVICE_FAILURE_WATCHDOG] = "watchdog",
3824         [SERVICE_FAILURE_START_LIMIT] = "start-limit"
3825 };
3826
3827 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3828
3829 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3830         [SERVICE_START_LIMIT_NONE] = "none",
3831         [SERVICE_START_LIMIT_REBOOT] = "reboot",
3832         [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3833         [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3834 };
3835 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3836
3837 const UnitVTable service_vtable = {
3838         .object_size = sizeof(Service),
3839         .exec_context_offset = offsetof(Service, exec_context),
3840
3841         .sections =
3842                 "Unit\0"
3843                 "Service\0"
3844                 "Install\0",
3845
3846         .init = service_init,
3847         .done = service_done,
3848         .load = service_load,
3849
3850         .coldplug = service_coldplug,
3851
3852         .dump = service_dump,
3853
3854         .start = service_start,
3855         .stop = service_stop,
3856         .reload = service_reload,
3857
3858         .can_reload = service_can_reload,
3859
3860         .kill = service_kill,
3861
3862         .serialize = service_serialize,
3863         .deserialize_item = service_deserialize_item,
3864
3865         .active_state = service_active_state,
3866         .sub_state_to_string = service_sub_state_to_string,
3867
3868         .check_gc = service_check_gc,
3869         .check_snapshot = service_check_snapshot,
3870
3871         .sigchld_event = service_sigchld_event,
3872         .timer_event = service_timer_event,
3873         .fd_event = service_fd_event,
3874
3875         .reset_failed = service_reset_failed,
3876
3877         .cgroup_notify_empty = service_cgroup_notify_event,
3878         .notify_message = service_notify_message,
3879
3880         .bus_name_owner_change = service_bus_name_owner_change,
3881         .bus_query_pid_done = service_bus_query_pid_done,
3882
3883         .bus_interface = "org.freedesktop.systemd1.Service",
3884         .bus_message_handler = bus_service_message_handler,
3885         .bus_invalidating_properties =  bus_service_invalidating_properties,
3886
3887 #ifdef HAVE_SYSV_COMPAT
3888         .enumerate = service_enumerate,
3889 #endif
3890         .status_message_formats = {
3891                 .starting_stopping = {
3892                         [0] = "Starting %s...",
3893                         [1] = "Stopping %s...",
3894                 },
3895                 .finished_start_job = {
3896                         [JOB_DONE]       = "Started %s.",
3897                         [JOB_FAILED]     = "Failed to start %s.",
3898                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
3899                         [JOB_TIMEOUT]    = "Timed out starting %s.",
3900                 },
3901                 .finished_stop_job = {
3902                         [JOB_DONE]       = "Stopped %s.",
3903                         [JOB_FAILED]     = "Stopped (with error) %s.",
3904                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
3905                 },
3906         },
3907 };