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