src/core/service.c

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