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