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