src/core/service.c

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