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