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