src/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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
1139                 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
1140                 return -EINVAL;
1141         }
1142
1143         return 0;
1144 }
1145
1146 static int service_add_default_dependencies(Service *s) {
1147         int r;
1148
1149         assert(s);
1150
1151         /* Add a number of automatic dependencies useful for the
1152          * majority of services. */
1153
1154         /* First, pull in base system */
1155         if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
1156
1157                 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_BASIC_TARGET, NULL, true)) < 0)
1158                         return r;
1159
1160         } else if (UNIT(s)->manager->running_as == MANAGER_USER) {
1161
1162                 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
1163                         return r;
1164         }
1165
1166         /* Second, activate normal shutdown */
1167         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
1168 }
1169
1170 static void service_fix_output(Service *s) {
1171         assert(s);
1172
1173         /* If nothing has been explicitly configured, patch default
1174          * output in. If input is socket/tty we avoid this however,
1175          * since in that case we want output to default to the same
1176          * place as we read input from. */
1177
1178         if (s->exec_context.std_error == EXEC_OUTPUT_INHERIT &&
1179             s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1180             s->exec_context.std_input == EXEC_INPUT_NULL)
1181                 s->exec_context.std_error = UNIT(s)->manager->default_std_error;
1182
1183         if (s->exec_context.std_output == EXEC_OUTPUT_INHERIT &&
1184             s->exec_context.std_input == EXEC_INPUT_NULL)
1185                 s->exec_context.std_output = UNIT(s)->manager->default_std_output;
1186 }
1187
1188 static int service_load(Unit *u) {
1189         int r;
1190         Service *s = SERVICE(u);
1191
1192         assert(s);
1193
1194         /* Load a .service file */
1195         if ((r = unit_load_fragment(u)) < 0)
1196                 return r;
1197
1198 #ifdef HAVE_SYSV_COMPAT
1199         /* Load a classic init script as a fallback, if we couldn't find anything */
1200         if (u->load_state == UNIT_STUB)
1201                 if ((r = service_load_sysv(s)) < 0)
1202                         return r;
1203 #endif
1204
1205         /* Still nothing found? Then let's give up */
1206         if (u->load_state == UNIT_STUB)
1207                 return -ENOENT;
1208
1209         /* We were able to load something, then let's add in the
1210          * dropin directories. */
1211         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
1212                 return r;
1213
1214         /* This is a new unit? Then let's add in some extras */
1215         if (u->load_state == UNIT_LOADED) {
1216                 service_fix_output(s);
1217
1218                 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
1219                         return r;
1220
1221                 if ((r = unit_add_default_cgroups(u)) < 0)
1222                         return r;
1223
1224 #ifdef HAVE_SYSV_COMPAT
1225                 if ((r = sysv_fix_order(s)) < 0)
1226                         return r;
1227 #endif
1228
1229                 if ((r = fsck_fix_order(s)) < 0)
1230                         return r;
1231
1232                 if (s->bus_name)
1233                         if ((r = unit_watch_bus_name(u, s->bus_name)) < 0)
1234                                 return r;
1235
1236                 if (s->type == SERVICE_NOTIFY && s->notify_access == NOTIFY_NONE)
1237                         s->notify_access = NOTIFY_MAIN;
1238
1239                 if (s->watchdog_usec > 0 && s->notify_access == NOTIFY_NONE)
1240                         s->notify_access = NOTIFY_MAIN;
1241
1242                 if (s->type == SERVICE_DBUS || s->bus_name)
1243                         if ((r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_DBUS_SOCKET, NULL, true)) < 0)
1244                                 return r;
1245
1246                 if (UNIT(s)->default_dependencies)
1247                         if ((r = service_add_default_dependencies(s)) < 0)
1248                                 return r;
1249         }
1250
1251         return service_verify(s);
1252 }
1253
1254 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1255
1256         ServiceExecCommand c;
1257         Service *s = SERVICE(u);
1258         const char *prefix2;
1259         char *p2;
1260
1261         assert(s);
1262
1263         p2 = strappend(prefix, "\t");
1264         prefix2 = p2 ? p2 : prefix;
1265
1266         fprintf(f,
1267                 "%sService State: %s\n"
1268                 "%sResult: %s\n"
1269                 "%sReload Result: %s\n"
1270                 "%sPermissionsStartOnly: %s\n"
1271                 "%sRootDirectoryStartOnly: %s\n"
1272                 "%sRemainAfterExit: %s\n"
1273                 "%sGuessMainPID: %s\n"
1274                 "%sType: %s\n"
1275                 "%sRestart: %s\n"
1276                 "%sNotifyAccess: %s\n",
1277                 prefix, service_state_to_string(s->state),
1278                 prefix, service_result_to_string(s->result),
1279                 prefix, service_result_to_string(s->reload_result),
1280                 prefix, yes_no(s->permissions_start_only),
1281                 prefix, yes_no(s->root_directory_start_only),
1282                 prefix, yes_no(s->remain_after_exit),
1283                 prefix, yes_no(s->guess_main_pid),
1284                 prefix, service_type_to_string(s->type),
1285                 prefix, service_restart_to_string(s->restart),
1286                 prefix, notify_access_to_string(s->notify_access));
1287
1288         if (s->control_pid > 0)
1289                 fprintf(f,
1290                         "%sControl PID: %lu\n",
1291                         prefix, (unsigned long) s->control_pid);
1292
1293         if (s->main_pid > 0)
1294                 fprintf(f,
1295                         "%sMain PID: %lu\n"
1296                         "%sMain PID Known: %s\n"
1297                         "%sMain PID Alien: %s\n",
1298                         prefix, (unsigned long) s->main_pid,
1299                         prefix, yes_no(s->main_pid_known),
1300                         prefix, yes_no(s->main_pid_alien));
1301
1302         if (s->pid_file)
1303                 fprintf(f,
1304                         "%sPIDFile: %s\n",
1305                         prefix, s->pid_file);
1306
1307         if (s->bus_name)
1308                 fprintf(f,
1309                         "%sBusName: %s\n"
1310                         "%sBus Name Good: %s\n",
1311                         prefix, s->bus_name,
1312                         prefix, yes_no(s->bus_name_good));
1313
1314         exec_context_dump(&s->exec_context, f, prefix);
1315
1316         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1317
1318                 if (!s->exec_command[c])
1319                         continue;
1320
1321                 fprintf(f, "%s-> %s:\n",
1322                         prefix, service_exec_command_to_string(c));
1323
1324                 exec_command_dump_list(s->exec_command[c], f, prefix2);
1325         }
1326
1327 #ifdef HAVE_SYSV_COMPAT
1328         if (s->sysv_path)
1329                 fprintf(f,
1330                         "%sSysV Init Script Path: %s\n"
1331                         "%sSysV Init Script has LSB Header: %s\n"
1332                         "%sSysVEnabled: %s\n",
1333                         prefix, s->sysv_path,
1334                         prefix, yes_no(s->sysv_has_lsb),
1335                         prefix, yes_no(s->sysv_enabled));
1336
1337         if (s->sysv_start_priority >= 0)
1338                 fprintf(f,
1339                         "%sSysVStartPriority: %i\n",
1340                         prefix, s->sysv_start_priority);
1341
1342         if (s->sysv_runlevels)
1343                 fprintf(f, "%sSysVRunLevels: %s\n",
1344                         prefix, s->sysv_runlevels);
1345 #endif
1346
1347         if (s->fsck_passno > 0)
1348                 fprintf(f,
1349                         "%sFsckPassNo: %i\n",
1350                         prefix, s->fsck_passno);
1351
1352         if (s->status_text)
1353                 fprintf(f, "%sStatus Text: %s\n",
1354                         prefix, s->status_text);
1355
1356         free(p2);
1357 }
1358
1359 static int service_load_pid_file(Service *s, bool may_warn) {
1360         char *k;
1361         int r;
1362         pid_t pid;
1363
1364         assert(s);
1365
1366         if (!s->pid_file)
1367                 return -ENOENT;
1368
1369         if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1370                 if (may_warn)
1371                         log_info("PID file %s not readable (yet?) after %s.",
1372                                  s->pid_file, service_state_to_string(s->state));
1373                 return r;
1374         }
1375
1376         r = parse_pid(k, &pid);
1377         free(k);
1378
1379         if (r < 0)
1380                 return r;
1381
1382         if (kill(pid, 0) < 0 && errno != EPERM) {
1383                 if (may_warn)
1384                         log_info("PID %lu read from file %s does not exist.",
1385                                  (unsigned long) pid, s->pid_file);
1386                 return -ESRCH;
1387         }
1388
1389         if (s->main_pid_known) {
1390                 if (pid == s->main_pid)
1391                         return 0;
1392
1393                 log_debug("Main PID changing: %lu -> %lu",
1394                           (unsigned long) s->main_pid, (unsigned long) pid);
1395                 service_unwatch_main_pid(s);
1396                 s->main_pid_known = false;
1397         } else
1398                 log_debug("Main PID loaded: %lu", (unsigned long) pid);
1399
1400         if ((r = service_set_main_pid(s, pid)) < 0)
1401                 return r;
1402
1403         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1404                 /* FIXME: we need to do something here */
1405                 return r;
1406
1407         return 0;
1408 }
1409
1410 static int service_search_main_pid(Service *s) {
1411         pid_t pid;
1412         int r;
1413
1414         assert(s);
1415
1416         /* If we know it anyway, don't ever fallback to unreliable
1417          * heuristics */
1418         if (s->main_pid_known)
1419                 return 0;
1420
1421         if (!s->guess_main_pid)
1422                 return 0;
1423
1424         assert(s->main_pid <= 0);
1425
1426         if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1427                 return -ENOENT;
1428
1429         log_debug("Main PID guessed: %lu", (unsigned long) pid);
1430         if ((r = service_set_main_pid(s, pid)) < 0)
1431                 return r;
1432
1433         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1434                 /* FIXME: we need to do something here */
1435                 return r;
1436
1437         return 0;
1438 }
1439
1440 static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1441         Iterator i;
1442         Unit *u;
1443
1444         assert(s);
1445
1446         /* Notifies all our sockets when we die */
1447
1448         if (s->socket_fd >= 0)
1449                 return;
1450
1451         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1452                 if (u->type == UNIT_SOCKET)
1453                         socket_notify_service_dead(SOCKET(u), failed_permanent);
1454
1455         return;
1456 }
1457
1458 static void service_set_state(Service *s, ServiceState state) {
1459         ServiceState old_state;
1460         assert(s);
1461
1462         old_state = s->state;
1463         s->state = state;
1464
1465         service_unwatch_pid_file(s);
1466
1467         if (state != SERVICE_START_PRE &&
1468             state != SERVICE_START &&
1469             state != SERVICE_START_POST &&
1470             state != SERVICE_RELOAD &&
1471             state != SERVICE_STOP &&
1472             state != SERVICE_STOP_SIGTERM &&
1473             state != SERVICE_STOP_SIGKILL &&
1474             state != SERVICE_STOP_POST &&
1475             state != SERVICE_FINAL_SIGTERM &&
1476             state != SERVICE_FINAL_SIGKILL &&
1477             state != SERVICE_AUTO_RESTART)
1478                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1479
1480         if (state != SERVICE_START &&
1481             state != SERVICE_START_POST &&
1482             state != SERVICE_RUNNING &&
1483             state != SERVICE_RELOAD &&
1484             state != SERVICE_STOP &&
1485             state != SERVICE_STOP_SIGTERM &&
1486             state != SERVICE_STOP_SIGKILL) {
1487                 service_unwatch_main_pid(s);
1488                 s->main_command = NULL;
1489         }
1490
1491         if (state != SERVICE_START_PRE &&
1492             state != SERVICE_START &&
1493             state != SERVICE_START_POST &&
1494             state != SERVICE_RELOAD &&
1495             state != SERVICE_STOP &&
1496             state != SERVICE_STOP_SIGTERM &&
1497             state != SERVICE_STOP_SIGKILL &&
1498             state != SERVICE_STOP_POST &&
1499             state != SERVICE_FINAL_SIGTERM &&
1500             state != SERVICE_FINAL_SIGKILL) {
1501                 service_unwatch_control_pid(s);
1502                 s->control_command = NULL;
1503                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1504         }
1505
1506         if (state == SERVICE_DEAD ||
1507             state == SERVICE_STOP ||
1508             state == SERVICE_STOP_SIGTERM ||
1509             state == SERVICE_STOP_SIGKILL ||
1510             state == SERVICE_STOP_POST ||
1511             state == SERVICE_FINAL_SIGTERM ||
1512             state == SERVICE_FINAL_SIGKILL ||
1513             state == SERVICE_FAILED ||
1514             state == SERVICE_AUTO_RESTART)
1515                 service_notify_sockets_dead(s, false);
1516
1517         if (state != SERVICE_START_PRE &&
1518             state != SERVICE_START &&
1519             state != SERVICE_START_POST &&
1520             state != SERVICE_RUNNING &&
1521             state != SERVICE_RELOAD &&
1522             state != SERVICE_STOP &&
1523             state != SERVICE_STOP_SIGTERM &&
1524             state != SERVICE_STOP_SIGKILL &&
1525             state != SERVICE_STOP_POST &&
1526             state != SERVICE_FINAL_SIGTERM &&
1527             state != SERVICE_FINAL_SIGKILL &&
1528             !(state == SERVICE_DEAD && UNIT(s)->job)) {
1529                 service_close_socket_fd(s);
1530                 service_connection_unref(s);
1531         }
1532
1533         if (state == SERVICE_STOP)
1534                 service_stop_watchdog(s);
1535
1536         /* For the inactive states unit_notify() will trim the cgroup,
1537          * but for exit we have to do that ourselves... */
1538         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1539                 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1540
1541         if (old_state != state)
1542                 log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1543
1544         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], s->reload_result == SERVICE_SUCCESS);
1545         s->reload_result = SERVICE_SUCCESS;
1546 }
1547
1548 static int service_coldplug(Unit *u) {
1549         Service *s = SERVICE(u);
1550         int r;
1551
1552         assert(s);
1553         assert(s->state == SERVICE_DEAD);
1554
1555         if (s->deserialized_state != s->state) {
1556
1557                 if (s->deserialized_state == SERVICE_START_PRE ||
1558                     s->deserialized_state == SERVICE_START ||
1559                     s->deserialized_state == SERVICE_START_POST ||
1560                     s->deserialized_state == SERVICE_RELOAD ||
1561                     s->deserialized_state == SERVICE_STOP ||
1562                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1563                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1564                     s->deserialized_state == SERVICE_STOP_POST ||
1565                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1566                     s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1567                     s->deserialized_state == SERVICE_AUTO_RESTART) {
1568
1569                         if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_usec > 0) {
1570                                 usec_t k;
1571
1572                                 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_usec;
1573
1574                                 if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1575                                         return r;
1576                         }
1577                 }
1578
1579                 if ((s->deserialized_state == SERVICE_START &&
1580                      (s->type == SERVICE_FORKING ||
1581                       s->type == SERVICE_DBUS ||
1582                       s->type == SERVICE_ONESHOT ||
1583                       s->type == SERVICE_NOTIFY)) ||
1584                     s->deserialized_state == SERVICE_START_POST ||
1585                     s->deserialized_state == SERVICE_RUNNING ||
1586                     s->deserialized_state == SERVICE_RELOAD ||
1587                     s->deserialized_state == SERVICE_STOP ||
1588                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1589                     s->deserialized_state == SERVICE_STOP_SIGKILL)
1590                         if (s->main_pid > 0)
1591                                 if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1592                                         return r;
1593
1594                 if (s->deserialized_state == SERVICE_START_PRE ||
1595                     s->deserialized_state == SERVICE_START ||
1596                     s->deserialized_state == SERVICE_START_POST ||
1597                     s->deserialized_state == SERVICE_RELOAD ||
1598                     s->deserialized_state == SERVICE_STOP ||
1599                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1600                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1601                     s->deserialized_state == SERVICE_STOP_POST ||
1602                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1603                     s->deserialized_state == SERVICE_FINAL_SIGKILL)
1604                         if (s->control_pid > 0)
1605                                 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1606                                         return r;
1607
1608                 if (s->deserialized_state == SERVICE_START_POST ||
1609                     s->deserialized_state == SERVICE_RUNNING)
1610                         service_handle_watchdog(s);
1611
1612                 service_set_state(s, s->deserialized_state);
1613         }
1614         return 0;
1615 }
1616
1617 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1618         Iterator i;
1619         int r;
1620         int *rfds = NULL;
1621         unsigned rn_fds = 0;
1622         Unit *u;
1623
1624         assert(s);
1625         assert(fds);
1626         assert(n_fds);
1627
1628         if (s->socket_fd >= 0)
1629                 return 0;
1630
1631         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1632                 int *cfds;
1633                 unsigned cn_fds;
1634                 Socket *sock;
1635
1636                 if (u->type != UNIT_SOCKET)
1637                         continue;
1638
1639                 sock = SOCKET(u);
1640
1641                 if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1642                         goto fail;
1643
1644                 if (!cfds)
1645                         continue;
1646
1647                 if (!rfds) {
1648                         rfds = cfds;
1649                         rn_fds = cn_fds;
1650                 } else {
1651                         int *t;
1652
1653                         if (!(t = new(int, rn_fds+cn_fds))) {
1654                                 free(cfds);
1655                                 r = -ENOMEM;
1656                                 goto fail;
1657                         }
1658
1659                         memcpy(t, rfds, rn_fds * sizeof(int));
1660                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1661                         free(rfds);
1662                         free(cfds);
1663
1664                         rfds = t;
1665                         rn_fds = rn_fds+cn_fds;
1666                 }
1667         }
1668
1669         *fds = rfds;
1670         *n_fds = rn_fds;
1671
1672         return 0;
1673
1674 fail:
1675         free(rfds);
1676
1677         return r;
1678 }
1679
1680 static int service_spawn(
1681                 Service *s,
1682                 ExecCommand *c,
1683                 bool timeout,
1684                 bool pass_fds,
1685                 bool apply_permissions,
1686                 bool apply_chroot,
1687                 bool apply_tty_stdin,
1688                 bool set_notify_socket,
1689                 pid_t *_pid) {
1690
1691         pid_t pid;
1692         int r;
1693         int *fds = NULL, *fdsbuf = NULL;
1694         unsigned n_fds = 0, n_env = 0;
1695         char **argv = NULL, **final_env = NULL, **our_env = NULL;
1696
1697         assert(s);
1698         assert(c);
1699         assert(_pid);
1700
1701         if (pass_fds ||
1702             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1703             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1704             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1705
1706                 if (s->socket_fd >= 0) {
1707                         fds = &s->socket_fd;
1708                         n_fds = 1;
1709                 } else {
1710                         if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1711                                 goto fail;
1712
1713                         fds = fdsbuf;
1714                 }
1715         }
1716
1717         if (timeout && s->timeout_usec) {
1718                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1719                         goto fail;
1720         } else
1721                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1722
1723         if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1724                 r = -ENOMEM;
1725                 goto fail;
1726         }
1727
1728         if (!(our_env = new0(char*, 4))) {
1729                 r = -ENOMEM;
1730                 goto fail;
1731         }
1732
1733         if (set_notify_socket)
1734                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1735                         r = -ENOMEM;
1736                         goto fail;
1737                 }
1738
1739         if (s->main_pid > 0)
1740                 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1741                         r = -ENOMEM;
1742                         goto fail;
1743                 }
1744
1745         if (s->watchdog_usec > 0)
1746                 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1747                         r = -ENOMEM;
1748                         goto fail;
1749                 }
1750
1751         if (!(final_env = strv_env_merge(2,
1752                                          UNIT(s)->manager->environment,
1753                                          our_env,
1754                                          NULL))) {
1755                 r = -ENOMEM;
1756                 goto fail;
1757         }
1758
1759         r = exec_spawn(c,
1760                        argv,
1761                        &s->exec_context,
1762                        fds, n_fds,
1763                        final_env,
1764                        apply_permissions,
1765                        apply_chroot,
1766                        apply_tty_stdin,
1767                        UNIT(s)->manager->confirm_spawn,
1768                        UNIT(s)->cgroup_bondings,
1769                        UNIT(s)->cgroup_attributes,
1770                        &pid);
1771
1772         if (r < 0)
1773                 goto fail;
1774
1775
1776         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1777                 /* FIXME: we need to do something here */
1778                 goto fail;
1779
1780         free(fdsbuf);
1781         strv_free(argv);
1782         strv_free(our_env);
1783         strv_free(final_env);
1784
1785         *_pid = pid;
1786
1787         return 0;
1788
1789 fail:
1790         free(fdsbuf);
1791         strv_free(argv);
1792         strv_free(our_env);
1793         strv_free(final_env);
1794
1795         if (timeout)
1796                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1797
1798         return r;
1799 }
1800
1801 static int main_pid_good(Service *s) {
1802         assert(s);
1803
1804         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1805          * don't know */
1806
1807         /* If we know the pid file, then lets just check if it is
1808          * still valid */
1809         if (s->main_pid_known) {
1810
1811                 /* If it's an alien child let's check if it is still
1812                  * alive ... */
1813                 if (s->main_pid_alien)
1814                         return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1815
1816                 /* .. otherwise assume we'll get a SIGCHLD for it,
1817                  * which we really should wait for to collect exit
1818                  * status and code */
1819                 return s->main_pid > 0;
1820         }
1821
1822         /* We don't know the pid */
1823         return -EAGAIN;
1824 }
1825
1826 static int control_pid_good(Service *s) {
1827         assert(s);
1828
1829         return s->control_pid > 0;
1830 }
1831
1832 static int cgroup_good(Service *s) {
1833         int r;
1834
1835         assert(s);
1836
1837         if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1838                 return r;
1839
1840         return !r;
1841 }
1842
1843 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1844         int r;
1845         assert(s);
1846
1847         if (f != SERVICE_SUCCESS)
1848                 s->result = f;
1849
1850         if (allow_restart &&
1851             !s->forbid_restart &&
1852             (s->restart == SERVICE_RESTART_ALWAYS ||
1853              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1854              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1855              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1856                                                          s->result == SERVICE_FAILURE_CORE_DUMP)))) {
1857
1858                 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1859                 if (r < 0)
1860                         goto fail;
1861
1862                 service_set_state(s, SERVICE_AUTO_RESTART);
1863         } else
1864                 service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1865
1866         s->forbid_restart = false;
1867
1868         return;
1869
1870 fail:
1871         log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1872         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1873 }
1874
1875 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1876
1877 static void service_enter_stop_post(Service *s, ServiceResult f) {
1878         int r;
1879         assert(s);
1880
1881         if (f != SERVICE_SUCCESS)
1882                 s->result = f;
1883
1884         service_unwatch_control_pid(s);
1885
1886         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1887                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1888
1889                 if ((r = service_spawn(s,
1890                                        s->control_command,
1891                                        true,
1892                                        false,
1893                                        !s->permissions_start_only,
1894                                        !s->root_directory_start_only,
1895                                        true,
1896                                        false,
1897                                        &s->control_pid)) < 0)
1898                         goto fail;
1899
1900
1901                 service_set_state(s, SERVICE_STOP_POST);
1902         } else
1903                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1904
1905         return;
1906
1907 fail:
1908         log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1909         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1910 }
1911
1912 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1913         int r;
1914         Set *pid_set = NULL;
1915         bool wait_for_exit = false;
1916
1917         assert(s);
1918
1919         if (f != SERVICE_SUCCESS)
1920                 s->result = f;
1921
1922         if (s->exec_context.kill_mode != KILL_NONE) {
1923                 int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1924
1925                 if (s->main_pid > 0) {
1926                         if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1927                                 log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1928                         else
1929                                 wait_for_exit = !s->main_pid_alien;
1930                 }
1931
1932                 if (s->control_pid > 0) {
1933                         if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1934                                 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1935                         else
1936                                 wait_for_exit = true;
1937                 }
1938
1939                 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1940
1941                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1942                                 r = -ENOMEM;
1943                                 goto fail;
1944                         }
1945
1946                         /* Exclude the main/control pids from being killed via the cgroup */
1947                         if (s->main_pid > 0)
1948                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
1949                                         goto fail;
1950
1951                         if (s->control_pid > 0)
1952                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1953                                         goto fail;
1954
1955                         if ((r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, pid_set)) < 0) {
1956                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1957                                         log_warning("Failed to kill control group: %s", strerror(-r));
1958                         } else if (r > 0)
1959                                 wait_for_exit = true;
1960
1961                         set_free(pid_set);
1962                         pid_set = NULL;
1963                 }
1964         }
1965
1966         if (wait_for_exit) {
1967                 if (s->timeout_usec > 0)
1968                         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1969                                 goto fail;
1970
1971                 service_set_state(s, state);
1972         } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1973                 service_enter_stop_post(s, SERVICE_SUCCESS);
1974         else
1975                 service_enter_dead(s, SERVICE_SUCCESS, true);
1976
1977         return;
1978
1979 fail:
1980         log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1981
1982         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
1983                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
1984         else
1985                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
1986
1987         if (pid_set)
1988                 set_free(pid_set);
1989 }
1990
1991 static void service_enter_stop(Service *s, ServiceResult f) {
1992         int r;
1993
1994         assert(s);
1995
1996         if (f != SERVICE_SUCCESS)
1997                 s->result = f;
1998
1999         service_unwatch_control_pid(s);
2000
2001         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2002                 s->control_command_id = SERVICE_EXEC_STOP;
2003
2004                 if ((r = service_spawn(s,
2005                                        s->control_command,
2006                                        true,
2007                                        false,
2008                                        !s->permissions_start_only,
2009                                        !s->root_directory_start_only,
2010                                        false,
2011                                        false,
2012                                        &s->control_pid)) < 0)
2013                         goto fail;
2014
2015                 service_set_state(s, SERVICE_STOP);
2016         } else
2017                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2018
2019         return;
2020
2021 fail:
2022         log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2023         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2024 }
2025
2026 static void service_enter_running(Service *s, ServiceResult f) {
2027         int main_pid_ok, cgroup_ok;
2028         assert(s);
2029
2030         if (f != SERVICE_SUCCESS)
2031                 s->result = f;
2032
2033         main_pid_ok = main_pid_good(s);
2034         cgroup_ok = cgroup_good(s);
2035
2036         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2037             (s->bus_name_good || s->type != SERVICE_DBUS))
2038                 service_set_state(s, SERVICE_RUNNING);
2039         else if (s->remain_after_exit)
2040                 service_set_state(s, SERVICE_EXITED);
2041         else
2042                 service_enter_stop(s, SERVICE_SUCCESS);
2043 }
2044
2045 static void service_enter_start_post(Service *s) {
2046         int r;
2047         assert(s);
2048
2049         service_unwatch_control_pid(s);
2050
2051         if (s->watchdog_usec > 0)
2052                 service_reset_watchdog(s);
2053
2054         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2055                 s->control_command_id = SERVICE_EXEC_START_POST;
2056
2057                 if ((r = service_spawn(s,
2058                                        s->control_command,
2059                                        true,
2060                                        false,
2061                                        !s->permissions_start_only,
2062                                        !s->root_directory_start_only,
2063                                        false,
2064                                        false,
2065                                        &s->control_pid)) < 0)
2066                         goto fail;
2067
2068                 service_set_state(s, SERVICE_START_POST);
2069         } else
2070                 service_enter_running(s, SERVICE_SUCCESS);
2071
2072         return;
2073
2074 fail:
2075         log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2076         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2077 }
2078
2079 static void service_enter_start(Service *s) {
2080         pid_t pid;
2081         int r;
2082         ExecCommand *c;
2083
2084         assert(s);
2085
2086         assert(s->exec_command[SERVICE_EXEC_START]);
2087         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2088
2089         if (s->type == SERVICE_FORKING)
2090                 service_unwatch_control_pid(s);
2091         else
2092                 service_unwatch_main_pid(s);
2093
2094         /* We want to ensure that nobody leaks processes from
2095          * START_PRE here, so let's go on a killing spree, People
2096          * should not spawn long running processes from START_PRE. */
2097         cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, NULL);
2098
2099         if (s->type == SERVICE_FORKING) {
2100                 s->control_command_id = SERVICE_EXEC_START;
2101                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2102
2103                 s->main_command = NULL;
2104         } else {
2105                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2106                 s->control_command = NULL;
2107
2108                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2109         }
2110
2111         if ((r = service_spawn(s,
2112                                c,
2113                                s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY,
2114                                true,
2115                                true,
2116                                true,
2117                                true,
2118                                s->notify_access != NOTIFY_NONE,
2119                                &pid)) < 0)
2120                 goto fail;
2121
2122         if (s->type == SERVICE_SIMPLE) {
2123                 /* For simple services we immediately start
2124                  * the START_POST binaries. */
2125
2126                 service_set_main_pid(s, pid);
2127                 service_enter_start_post(s);
2128
2129         } else  if (s->type == SERVICE_FORKING) {
2130
2131                 /* For forking services we wait until the start
2132                  * process exited. */
2133
2134                 s->control_pid = pid;
2135                 service_set_state(s, SERVICE_START);
2136
2137         } else if (s->type == SERVICE_ONESHOT ||
2138                    s->type == SERVICE_DBUS ||
2139                    s->type == SERVICE_NOTIFY) {
2140
2141                 /* For oneshot services we wait until the start
2142                  * process exited, too, but it is our main process. */
2143
2144                 /* For D-Bus services we know the main pid right away,
2145                  * but wait for the bus name to appear on the
2146                  * bus. Notify services are similar. */
2147
2148                 service_set_main_pid(s, pid);
2149                 service_set_state(s, SERVICE_START);
2150         } else
2151                 assert_not_reached("Unknown service type");
2152
2153         return;
2154
2155 fail:
2156         log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2157         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2158 }
2159
2160 static void service_enter_start_pre(Service *s) {
2161         int r;
2162
2163         assert(s);
2164
2165         service_unwatch_control_pid(s);
2166
2167         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2168
2169                 /* Before we start anything, let's clear up what might
2170                  * be left from previous runs. */
2171                 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, NULL);
2172
2173                 s->control_command_id = SERVICE_EXEC_START_PRE;
2174
2175                 if ((r = service_spawn(s,
2176                                        s->control_command,
2177                                        true,
2178                                        false,
2179                                        !s->permissions_start_only,
2180                                        !s->root_directory_start_only,
2181                                        true,
2182                                        false,
2183                                        &s->control_pid)) < 0)
2184                         goto fail;
2185
2186                 service_set_state(s, SERVICE_START_PRE);
2187         } else
2188                 service_enter_start(s);
2189
2190         return;
2191
2192 fail:
2193         log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2194         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2195 }
2196
2197 static void service_enter_restart(Service *s) {
2198         int r;
2199         DBusError error;
2200
2201         assert(s);
2202         dbus_error_init(&error);
2203
2204         if (UNIT(s)->job) {
2205                 log_info("Job pending for unit, delaying automatic restart.");
2206
2207                 if ((r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch)) < 0)
2208                         goto fail;
2209         }
2210
2211         service_enter_dead(s, SERVICE_SUCCESS, false);
2212
2213         if ((r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(s), JOB_FAIL, false, &error, NULL)) < 0)
2214                 goto fail;
2215
2216         log_debug("%s scheduled restart job.", UNIT(s)->id);
2217         return;
2218
2219 fail:
2220         log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2221         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2222
2223         dbus_error_free(&error);
2224 }
2225
2226 static void service_enter_reload(Service *s) {
2227         int r;
2228
2229         assert(s);
2230
2231         service_unwatch_control_pid(s);
2232
2233         if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2234                 s->control_command_id = SERVICE_EXEC_RELOAD;
2235
2236                 if ((r = service_spawn(s,
2237                                        s->control_command,
2238                                        true,
2239                                        false,
2240                                        !s->permissions_start_only,
2241                                        !s->root_directory_start_only,
2242                                        false,
2243                                        false,
2244                                        &s->control_pid)) < 0)
2245                         goto fail;
2246
2247                 service_set_state(s, SERVICE_RELOAD);
2248         } else
2249                 service_enter_running(s, SERVICE_SUCCESS);
2250
2251         return;
2252
2253 fail:
2254         log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2255         s->reload_result = SERVICE_FAILURE_RESOURCES;
2256         service_enter_running(s, SERVICE_SUCCESS);
2257 }
2258
2259 static void service_run_next_control(Service *s) {
2260         int r;
2261
2262         assert(s);
2263         assert(s->control_command);
2264         assert(s->control_command->command_next);
2265
2266         assert(s->control_command_id != SERVICE_EXEC_START);
2267
2268         s->control_command = s->control_command->command_next;
2269         service_unwatch_control_pid(s);
2270
2271         if ((r = service_spawn(s,
2272                                s->control_command,
2273                                true,
2274                                false,
2275                                !s->permissions_start_only,
2276                                !s->root_directory_start_only,
2277                                s->control_command_id == SERVICE_EXEC_START_PRE ||
2278                                s->control_command_id == SERVICE_EXEC_STOP_POST,
2279                                false,
2280                                &s->control_pid)) < 0)
2281                 goto fail;
2282
2283         return;
2284
2285 fail:
2286         log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2287
2288         if (s->state == SERVICE_START_PRE)
2289                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2290         else if (s->state == SERVICE_STOP)
2291                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2292         else if (s->state == SERVICE_STOP_POST)
2293                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2294         else if (s->state == SERVICE_RELOAD) {
2295                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2296                 service_enter_running(s, SERVICE_SUCCESS);
2297         } else
2298                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2299 }
2300
2301 static void service_run_next_main(Service *s) {
2302         pid_t pid;
2303         int r;
2304
2305         assert(s);
2306         assert(s->main_command);
2307         assert(s->main_command->command_next);
2308         assert(s->type == SERVICE_ONESHOT);
2309
2310         s->main_command = s->main_command->command_next;
2311         service_unwatch_main_pid(s);
2312
2313         if ((r = service_spawn(s,
2314                                s->main_command,
2315                                false,
2316                                true,
2317                                true,
2318                                true,
2319                                true,
2320                                s->notify_access != NOTIFY_NONE,
2321                                &pid)) < 0)
2322                 goto fail;
2323
2324         service_set_main_pid(s, pid);
2325
2326         return;
2327
2328 fail:
2329         log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2330         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2331 }
2332
2333 static int service_start_limit_test(Service *s) {
2334         assert(s);
2335
2336         if (ratelimit_test(&s->start_limit))
2337                 return 0;
2338
2339         switch (s->start_limit_action) {
2340
2341         case SERVICE_START_LIMIT_NONE:
2342                 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2343                 break;
2344
2345         case SERVICE_START_LIMIT_REBOOT: {
2346                 DBusError error;
2347                 int r;
2348
2349                 dbus_error_init(&error);
2350
2351                 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2352
2353                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2354                 if (r < 0) {
2355                         log_error("Failed to reboot: %s.", bus_error(&error, r));
2356                         dbus_error_free(&error);
2357                 }
2358
2359                 break;
2360         }
2361
2362         case SERVICE_START_LIMIT_REBOOT_FORCE:
2363                 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2364                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2365                 break;
2366
2367         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2368                 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2369                 reboot(RB_AUTOBOOT);
2370                 break;
2371
2372         default:
2373                 log_error("start limit action=%i", s->start_limit_action);
2374                 assert_not_reached("Unknown StartLimitAction.");
2375         }
2376
2377         return -ECANCELED;
2378 }
2379
2380 static int service_start(Unit *u) {
2381         Service *s = SERVICE(u);
2382         int r;
2383
2384         assert(s);
2385
2386         /* We cannot fulfill this request right now, try again later
2387          * please! */
2388         if (s->state == SERVICE_STOP ||
2389             s->state == SERVICE_STOP_SIGTERM ||
2390             s->state == SERVICE_STOP_SIGKILL ||
2391             s->state == SERVICE_STOP_POST ||
2392             s->state == SERVICE_FINAL_SIGTERM ||
2393             s->state == SERVICE_FINAL_SIGKILL)
2394                 return -EAGAIN;
2395
2396         /* Already on it! */
2397         if (s->state == SERVICE_START_PRE ||
2398             s->state == SERVICE_START ||
2399             s->state == SERVICE_START_POST)
2400                 return 0;
2401
2402         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED || s->state == SERVICE_AUTO_RESTART);
2403
2404         /* Make sure we don't enter a busy loop of some kind. */
2405         r = service_start_limit_test(s);
2406         if (r < 0) {
2407                 service_notify_sockets_dead(s, true);
2408                 return r;
2409         }
2410
2411         s->result = SERVICE_SUCCESS;
2412         s->reload_result = SERVICE_SUCCESS;
2413         s->main_pid_known = false;
2414         s->main_pid_alien = false;
2415         s->forbid_restart = false;
2416
2417         service_enter_start_pre(s);
2418         return 0;
2419 }
2420
2421 static int service_stop(Unit *u) {
2422         Service *s = SERVICE(u);
2423
2424         assert(s);
2425
2426         /* This is a user request, so don't do restarts on this
2427          * shutdown. */
2428         s->forbid_restart = true;
2429
2430         /* Already on it */
2431         if (s->state == SERVICE_STOP ||
2432             s->state == SERVICE_STOP_SIGTERM ||
2433             s->state == SERVICE_STOP_SIGKILL ||
2434             s->state == SERVICE_STOP_POST ||
2435             s->state == SERVICE_FINAL_SIGTERM ||
2436             s->state == SERVICE_FINAL_SIGKILL)
2437                 return 0;
2438
2439         /* Don't allow a restart */
2440         if (s->state == SERVICE_AUTO_RESTART) {
2441                 service_set_state(s, SERVICE_DEAD);
2442                 return 0;
2443         }
2444
2445         /* If there's already something running we go directly into
2446          * kill mode. */
2447         if (s->state == SERVICE_START_PRE ||
2448             s->state == SERVICE_START ||
2449             s->state == SERVICE_START_POST ||
2450             s->state == SERVICE_RELOAD) {
2451                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2452                 return 0;
2453         }
2454
2455         assert(s->state == SERVICE_RUNNING ||
2456                s->state == SERVICE_EXITED);
2457
2458         service_enter_stop(s, SERVICE_SUCCESS);
2459         return 0;
2460 }
2461
2462 static int service_reload(Unit *u) {
2463         Service *s = SERVICE(u);
2464
2465         assert(s);
2466
2467         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2468
2469         service_enter_reload(s);
2470         return 0;
2471 }
2472
2473 static bool service_can_reload(Unit *u) {
2474         Service *s = SERVICE(u);
2475
2476         assert(s);
2477
2478         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2479 }
2480
2481 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2482         Service *s = SERVICE(u);
2483
2484         assert(u);
2485         assert(f);
2486         assert(fds);
2487
2488         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2489         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2490         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2491
2492         if (s->control_pid > 0)
2493                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2494
2495         if (s->main_pid_known && s->main_pid > 0)
2496                 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2497
2498         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2499
2500         if (s->status_text)
2501                 unit_serialize_item(u, f, "status-text", s->status_text);
2502
2503         /* FIXME: There's a minor uncleanliness here: if there are
2504          * multiple commands attached here, we will start from the
2505          * first one again */
2506         if (s->control_command_id >= 0)
2507                 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2508
2509         if (s->socket_fd >= 0) {
2510                 int copy;
2511
2512                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2513                         return copy;
2514
2515                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2516         }
2517
2518         if (s->main_exec_status.pid > 0) {
2519                 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2520                 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2521                 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2522
2523                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2524                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2525                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2526                 }
2527         }
2528         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2529                 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2530
2531         return 0;
2532 }
2533
2534 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2535         Service *s = SERVICE(u);
2536
2537         assert(u);
2538         assert(key);
2539         assert(value);
2540         assert(fds);
2541
2542         if (streq(key, "state")) {
2543                 ServiceState state;
2544
2545                 if ((state = service_state_from_string(value)) < 0)
2546                         log_debug("Failed to parse state value %s", value);
2547                 else
2548                         s->deserialized_state = state;
2549         } else if (streq(key, "result")) {
2550                 ServiceResult f;
2551
2552                 f = service_result_from_string(value);
2553                 if (f < 0)
2554                         log_debug("Failed to parse result value %s", value);
2555                 else if (f != SERVICE_SUCCESS)
2556                         s->result = f;
2557
2558         } else if (streq(key, "reload-result")) {
2559                 ServiceResult f;
2560
2561                 f = service_result_from_string(value);
2562                 if (f < 0)
2563                         log_debug("Failed to parse reload result value %s", value);
2564                 else if (f != SERVICE_SUCCESS)
2565                         s->reload_result = f;
2566
2567         } else if (streq(key, "control-pid")) {
2568                 pid_t pid;
2569
2570                 if (parse_pid(value, &pid) < 0)
2571                         log_debug("Failed to parse control-pid value %s", value);
2572                 else
2573                         s->control_pid = pid;
2574         } else if (streq(key, "main-pid")) {
2575                 pid_t pid;
2576
2577                 if (parse_pid(value, &pid) < 0)
2578                         log_debug("Failed to parse main-pid value %s", value);
2579                 else
2580                         service_set_main_pid(s, (pid_t) pid);
2581         } else if (streq(key, "main-pid-known")) {
2582                 int b;
2583
2584                 if ((b = parse_boolean(value)) < 0)
2585                         log_debug("Failed to parse main-pid-known value %s", value);
2586                 else
2587                         s->main_pid_known = b;
2588         } else if (streq(key, "status-text")) {
2589                 char *t;
2590
2591                 if ((t = strdup(value))) {
2592                         free(s->status_text);
2593                         s->status_text = t;
2594                 }
2595
2596         } else if (streq(key, "control-command")) {
2597                 ServiceExecCommand id;
2598
2599                 if ((id = service_exec_command_from_string(value)) < 0)
2600                         log_debug("Failed to parse exec-command value %s", value);
2601                 else {
2602                         s->control_command_id = id;
2603                         s->control_command = s->exec_command[id];
2604                 }
2605         } else if (streq(key, "socket-fd")) {
2606                 int fd;
2607
2608                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2609                         log_debug("Failed to parse socket-fd value %s", value);
2610                 else {
2611
2612                         if (s->socket_fd >= 0)
2613                                 close_nointr_nofail(s->socket_fd);
2614                         s->socket_fd = fdset_remove(fds, fd);
2615                 }
2616         } else if (streq(key, "main-exec-status-pid")) {
2617                 pid_t pid;
2618
2619                 if (parse_pid(value, &pid) < 0)
2620                         log_debug("Failed to parse main-exec-status-pid value %s", value);
2621                 else
2622                         s->main_exec_status.pid = pid;
2623         } else if (streq(key, "main-exec-status-code")) {
2624                 int i;
2625
2626                 if (safe_atoi(value, &i) < 0)
2627                         log_debug("Failed to parse main-exec-status-code value %s", value);
2628                 else
2629                         s->main_exec_status.code = i;
2630         } else if (streq(key, "main-exec-status-status")) {
2631                 int i;
2632
2633                 if (safe_atoi(value, &i) < 0)
2634                         log_debug("Failed to parse main-exec-status-status value %s", value);
2635                 else
2636                         s->main_exec_status.status = i;
2637         } else if (streq(key, "main-exec-status-start"))
2638                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2639         else if (streq(key, "main-exec-status-exit"))
2640                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2641         else if (streq(key, "watchdog-timestamp"))
2642                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2643         else
2644                 log_debug("Unknown serialization key '%s'", key);
2645
2646         return 0;
2647 }
2648
2649 static UnitActiveState service_active_state(Unit *u) {
2650         assert(u);
2651
2652         return state_translation_table[SERVICE(u)->state];
2653 }
2654
2655 static const char *service_sub_state_to_string(Unit *u) {
2656         assert(u);
2657
2658         return service_state_to_string(SERVICE(u)->state);
2659 }
2660
2661 static bool service_check_gc(Unit *u) {
2662         Service *s = SERVICE(u);
2663
2664         assert(s);
2665
2666         /* Never clean up services that still have a process around,
2667          * even if the service is formally dead. */
2668         if (cgroup_good(s) > 0 ||
2669             main_pid_good(s) > 0 ||
2670             control_pid_good(s) > 0)
2671                 return true;
2672
2673 #ifdef HAVE_SYSV_COMPAT
2674         if (s->sysv_path)
2675                 return true;
2676 #endif
2677
2678         return false;
2679 }
2680
2681 static bool service_check_snapshot(Unit *u) {
2682         Service *s = SERVICE(u);
2683
2684         assert(s);
2685
2686         return !s->got_socket_fd;
2687 }
2688
2689 static int service_retry_pid_file(Service *s) {
2690         int r;
2691
2692         assert(s->pid_file);
2693         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2694
2695         r = service_load_pid_file(s, false);
2696         if (r < 0)
2697                 return r;
2698
2699         service_unwatch_pid_file(s);
2700
2701         service_enter_running(s, SERVICE_SUCCESS);
2702         return 0;
2703 }
2704
2705 static int service_watch_pid_file(Service *s) {
2706         int r;
2707
2708         log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2709         r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2710         if (r < 0)
2711                 goto fail;
2712
2713         /* the pidfile might have appeared just before we set the watch */
2714         service_retry_pid_file(s);
2715
2716         return 0;
2717 fail:
2718         log_error("Failed to set a watch for %s's PID file %s: %s",
2719                   UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2720         service_unwatch_pid_file(s);
2721         return r;
2722 }
2723
2724 static int service_demand_pid_file(Service *s) {
2725         PathSpec *ps;
2726
2727         assert(s->pid_file);
2728         assert(!s->pid_file_pathspec);
2729
2730         ps = new0(PathSpec, 1);
2731         if (!ps)
2732                 return -ENOMEM;
2733
2734         ps->path = strdup(s->pid_file);
2735         if (!ps->path) {
2736                 free(ps);
2737                 return -ENOMEM;
2738         }
2739
2740         path_kill_slashes(ps->path);
2741
2742         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2743          * keep their PID file open all the time. */
2744         ps->type = PATH_MODIFIED;
2745         ps->inotify_fd = -1;
2746
2747         s->pid_file_pathspec = ps;
2748
2749         return service_watch_pid_file(s);
2750 }
2751
2752 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2753         Service *s = SERVICE(u);
2754
2755         assert(s);
2756         assert(fd >= 0);
2757         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2758         assert(s->pid_file_pathspec);
2759         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2760
2761         log_debug("inotify event for %s", u->id);
2762
2763         if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2764                 goto fail;
2765
2766         if (service_retry_pid_file(s) == 0)
2767                 return;
2768
2769         if (service_watch_pid_file(s) < 0)
2770                 goto fail;
2771
2772         return;
2773 fail:
2774         service_unwatch_pid_file(s);
2775         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2776 }
2777
2778 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2779         Service *s = SERVICE(u);
2780         ServiceResult f;
2781
2782         assert(s);
2783         assert(pid >= 0);
2784
2785         if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2786                 f = SERVICE_SUCCESS;
2787         else if (code == CLD_EXITED)
2788                 f = SERVICE_FAILURE_EXIT_CODE;
2789         else if (code == CLD_KILLED)
2790                 f = SERVICE_FAILURE_SIGNAL;
2791         else if (code == CLD_DUMPED)
2792                 f = SERVICE_FAILURE_CORE_DUMP;
2793         else
2794                 assert_not_reached("Unknown code");
2795
2796         if (s->main_pid == pid) {
2797                 /* Forking services may occasionally move to a new PID.
2798                  * As long as they update the PID file before exiting the old
2799                  * PID, they're fine. */
2800                 if (service_load_pid_file(s, false) == 0)
2801                         return;
2802
2803                 s->main_pid = 0;
2804                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2805
2806                 /* If this is not a forking service than the main
2807                  * process got started and hence we copy the exit
2808                  * status so that it is recorded both as main and as
2809                  * control process exit status */
2810                 if (s->main_command) {
2811                         s->main_command->exec_status = s->main_exec_status;
2812
2813                         if (s->main_command->ignore)
2814                                 f = SERVICE_SUCCESS;
2815                 }
2816
2817                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2818                          "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2819
2820                 if (f != SERVICE_SUCCESS)
2821                         s->result = f;
2822
2823                 if (s->main_command &&
2824                     s->main_command->command_next &&
2825                     f == SERVICE_SUCCESS) {
2826
2827                         /* There is another command to *
2828                          * execute, so let's do that. */
2829
2830                         log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2831                         service_run_next_main(s);
2832
2833                 } else {
2834
2835                         /* The service exited, so the service is officially
2836                          * gone. */
2837                         s->main_command = NULL;
2838
2839                         switch (s->state) {
2840
2841                         case SERVICE_START_POST:
2842                         case SERVICE_RELOAD:
2843                         case SERVICE_STOP:
2844                                 /* Need to wait until the operation is
2845                                  * done */
2846                                 break;
2847
2848                         case SERVICE_START:
2849                                 if (s->type == SERVICE_ONESHOT) {
2850                                         /* This was our main goal, so let's go on */
2851                                         if (f == SERVICE_SUCCESS)
2852                                                 service_enter_start_post(s);
2853                                         else
2854                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2855                                         break;
2856                                 } else {
2857                                         assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2858
2859                                         /* Fall through */
2860                                 }
2861
2862                         case SERVICE_RUNNING:
2863                                 service_enter_running(s, f);
2864                                 break;
2865
2866                         case SERVICE_STOP_SIGTERM:
2867                         case SERVICE_STOP_SIGKILL:
2868
2869                                 if (!control_pid_good(s))
2870                                         service_enter_stop_post(s, f);
2871
2872                                 /* If there is still a control process, wait for that first */
2873                                 break;
2874
2875                         default:
2876                                 assert_not_reached("Uh, main process died at wrong time.");
2877                         }
2878                 }
2879
2880         } else if (s->control_pid == pid) {
2881
2882                 s->control_pid = 0;
2883
2884                 if (s->control_command) {
2885                         exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2886
2887                         if (s->control_command->ignore)
2888                                 f = SERVICE_SUCCESS;
2889                 }
2890
2891                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2892                          "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2893
2894                 if (f != SERVICE_SUCCESS)
2895                         s->result = f;
2896
2897                 if (s->control_command &&
2898                     s->control_command->command_next &&
2899                     f == SERVICE_SUCCESS) {
2900
2901                         /* There is another command to *
2902                          * execute, so let's do that. */
2903
2904                         log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2905                         service_run_next_control(s);
2906
2907                 } else {
2908                         /* No further commands for this step, so let's
2909                          * figure out what to do next */
2910
2911                         s->control_command = NULL;
2912                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2913
2914                         log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2915
2916                         switch (s->state) {
2917
2918                         case SERVICE_START_PRE:
2919                                 if (f == SERVICE_SUCCESS)
2920                                         service_enter_start(s);
2921                                 else
2922                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2923                                 break;
2924
2925                         case SERVICE_START:
2926                                 assert(s->type == SERVICE_FORKING);
2927
2928                                 if (f != SERVICE_SUCCESS) {
2929                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2930                                         break;
2931                                 }
2932
2933                                 if (s->pid_file) {
2934                                         bool has_start_post;
2935                                         int r;
2936
2937                                         /* Let's try to load the pid file here if we can.
2938                                          * The PID file might actually be created by a START_POST
2939                                          * script. In that case don't worry if the loading fails. */
2940
2941                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
2942                                         r = service_load_pid_file(s, !has_start_post);
2943                                         if (!has_start_post && r < 0) {
2944                                                 r = service_demand_pid_file(s);
2945                                                 if (r < 0 || !cgroup_good(s))
2946                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2947                                                 break;
2948                                         }
2949                                 } else
2950                                         service_search_main_pid(s);
2951
2952                                 service_enter_start_post(s);
2953                                 break;
2954
2955                         case SERVICE_START_POST:
2956                                 if (f != SERVICE_SUCCESS) {
2957                                         service_enter_stop(s, f);
2958                                         break;
2959                                 }
2960
2961                                 if (s->pid_file) {
2962                                         int r;
2963
2964                                         r = service_load_pid_file(s, true);
2965                                         if (r < 0) {
2966                                                 r = service_demand_pid_file(s);
2967                                                 if (r < 0 || !cgroup_good(s))
2968                                                         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2969                                                 break;
2970                                         }
2971                                 } else
2972                                         service_search_main_pid(s);
2973
2974                                 service_enter_running(s, SERVICE_SUCCESS);
2975                                 break;
2976
2977                         case SERVICE_RELOAD:
2978                                 if (f == SERVICE_SUCCESS) {
2979                                         service_load_pid_file(s, true);
2980                                         service_search_main_pid(s);
2981                                 }
2982
2983                                 s->reload_result = f;
2984                                 service_enter_running(s, SERVICE_SUCCESS);
2985                                 break;
2986
2987                         case SERVICE_STOP:
2988                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
2989                                 break;
2990
2991                         case SERVICE_STOP_SIGTERM:
2992                         case SERVICE_STOP_SIGKILL:
2993                                 if (main_pid_good(s) <= 0)
2994                                         service_enter_stop_post(s, f);
2995
2996                                 /* If there is still a service
2997                                  * process around, wait until
2998                                  * that one quit, too */
2999                                 break;
3000
3001                         case SERVICE_STOP_POST:
3002                         case SERVICE_FINAL_SIGTERM:
3003                         case SERVICE_FINAL_SIGKILL:
3004                                 service_enter_dead(s, f, true);
3005                                 break;
3006
3007                         default:
3008                                 assert_not_reached("Uh, control process died at wrong time.");
3009                         }
3010                 }
3011         }
3012
3013         /* Notify clients about changed exit status */
3014         unit_add_to_dbus_queue(u);
3015 }
3016
3017 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3018         Service *s = SERVICE(u);
3019
3020         assert(s);
3021         assert(elapsed == 1);
3022
3023         if (w == &s->watchdog_watch) {
3024                 service_handle_watchdog(s);
3025                 return;
3026         }
3027
3028         assert(w == &s->timer_watch);
3029
3030         switch (s->state) {
3031
3032         case SERVICE_START_PRE:
3033         case SERVICE_START:
3034                 log_warning("%s operation timed out. Terminating.", u->id);
3035                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3036                 break;
3037
3038         case SERVICE_START_POST:
3039                 log_warning("%s operation timed out. Stopping.", u->id);
3040                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3041                 break;
3042
3043         case SERVICE_RELOAD:
3044                 log_warning("%s operation timed out. Stopping.", u->id);
3045                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3046                 service_enter_running(s, SERVICE_SUCCESS);
3047                 break;
3048
3049         case SERVICE_STOP:
3050                 log_warning("%s stopping timed out. Terminating.", u->id);
3051                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3052                 break;
3053
3054         case SERVICE_STOP_SIGTERM:
3055                 if (s->exec_context.send_sigkill) {
3056                         log_warning("%s stopping timed out. Killing.", u->id);
3057                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3058                 } else {
3059                         log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3060                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3061                 }
3062
3063                 break;
3064
3065         case SERVICE_STOP_SIGKILL:
3066                 /* Uh, we sent a SIGKILL and it is still not gone?
3067                  * Must be something we cannot kill, so let's just be
3068                  * weirded out and continue */
3069
3070                 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3071                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3072                 break;
3073
3074         case SERVICE_STOP_POST:
3075                 log_warning("%s stopping timed out (2). Terminating.", u->id);
3076                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3077                 break;
3078
3079         case SERVICE_FINAL_SIGTERM:
3080                 if (s->exec_context.send_sigkill) {
3081                         log_warning("%s stopping timed out (2). Killing.", u->id);
3082                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3083                 } else {
3084                         log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3085                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3086                 }
3087
3088                 break;
3089
3090         case SERVICE_FINAL_SIGKILL:
3091                 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3092                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3093                 break;
3094
3095         case SERVICE_AUTO_RESTART:
3096                 log_info("%s holdoff time over, scheduling restart.", u->id);
3097                 service_enter_restart(s);
3098                 break;
3099
3100         default:
3101                 assert_not_reached("Timeout at wrong time.");
3102         }
3103 }
3104
3105 static void service_cgroup_notify_event(Unit *u) {
3106         Service *s = SERVICE(u);
3107
3108         assert(u);
3109
3110         log_debug("%s: cgroup is empty", u->id);
3111
3112         switch (s->state) {
3113
3114                 /* Waiting for SIGCHLD is usually more interesting,
3115                  * because it includes return codes/signals. Which is
3116                  * why we ignore the cgroup events for most cases,
3117                  * except when we don't know pid which to expect the
3118                  * SIGCHLD for. */
3119
3120         case SERVICE_START:
3121         case SERVICE_START_POST:
3122                 /* If we were hoping for the daemon to write its PID file,
3123                  * we can give up now. */
3124                 if (s->pid_file_pathspec) {
3125                         log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3126                         service_unwatch_pid_file(s);
3127                         if (s->state == SERVICE_START)
3128                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3129                         else
3130                                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3131                 }
3132                 break;
3133
3134         case SERVICE_RUNNING:
3135                 /* service_enter_running() will figure out what to do */
3136                 service_enter_running(s, SERVICE_SUCCESS);
3137                 break;
3138
3139         case SERVICE_STOP_SIGTERM:
3140         case SERVICE_STOP_SIGKILL:
3141
3142                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3143                         service_enter_stop_post(s, SERVICE_SUCCESS);
3144
3145                 break;
3146
3147         case SERVICE_FINAL_SIGTERM:
3148         case SERVICE_FINAL_SIGKILL:
3149                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3150                         service_enter_dead(s, SERVICE_SUCCESS, SERVICE_SUCCESS);
3151
3152                 break;
3153
3154         default:
3155                 ;
3156         }
3157 }
3158
3159 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3160         Service *s = SERVICE(u);
3161         const char *e;
3162
3163         assert(u);
3164
3165         if (s->notify_access == NOTIFY_NONE) {
3166                 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3167                             u->id, (unsigned long) pid);
3168                 return;
3169         }
3170
3171         if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3172                 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3173                             u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3174                 return;
3175         }
3176
3177         log_debug("%s: Got message", u->id);
3178
3179         /* Interpret MAINPID= */
3180         if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3181             (s->state == SERVICE_START ||
3182              s->state == SERVICE_START_POST ||
3183              s->state == SERVICE_RUNNING ||
3184              s->state == SERVICE_RELOAD)) {
3185
3186                 if (parse_pid(e + 8, &pid) < 0)
3187                         log_warning("Failed to parse notification message %s", e);
3188                 else {
3189                         log_debug("%s: got %s", u->id, e);
3190                         service_set_main_pid(s, pid);
3191                 }
3192         }
3193
3194         /* Interpret READY= */
3195         if (s->type == SERVICE_NOTIFY &&
3196             s->state == SERVICE_START &&
3197             strv_find(tags, "READY=1")) {
3198                 log_debug("%s: got READY=1", u->id);
3199
3200                 service_enter_start_post(s);
3201         }
3202
3203         /* Interpret STATUS= */
3204         e = strv_find_prefix(tags, "STATUS=");
3205         if (e) {
3206                 char *t;
3207
3208                 if (e[7]) {
3209
3210                         if (!utf8_is_valid(e+7)) {
3211                                 log_warning("Status message in notification is not UTF-8 clean.");
3212                                 return;
3213                         }
3214
3215                         t = strdup(e+7);
3216                         if (!t) {
3217                                 log_error("Failed to allocate string.");
3218                                 return;
3219                         }
3220
3221                         log_debug("%s: got %s", u->id, e);
3222
3223                         free(s->status_text);
3224                         s->status_text = t;
3225                 } else {
3226                         free(s->status_text);
3227                         s->status_text = NULL;
3228                 }
3229
3230         }
3231         if (strv_find(tags, "WATCHDOG=1")) {
3232                 log_debug("%s: got WATCHDOG=1", u->id);
3233                 service_reset_watchdog(s);
3234         }
3235
3236         /* Notify clients about changed status or main pid */
3237         unit_add_to_dbus_queue(u);
3238 }
3239
3240 #ifdef HAVE_SYSV_COMPAT
3241
3242 #ifdef TARGET_SUSE
3243 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3244         FILE *f=NULL;
3245         int r;
3246
3247         if (!(f = fopen("/etc/insserv.conf", "re"))) {
3248                 r = errno == ENOENT ? 0 : -errno;
3249                 goto finish;
3250         }
3251
3252         while (!feof(f)) {
3253                 char l[LINE_MAX], *t;
3254                 char **parsed = NULL;
3255
3256                 if (!fgets(l, sizeof(l), f)) {
3257                         if (feof(f))
3258                                 break;
3259
3260                         r = -errno;
3261                         log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3262                         goto finish;
3263                 }
3264
3265                 t = strstrip(l);
3266                 if (*t != '$' && *t != '<')
3267                         continue;
3268
3269                 parsed = strv_split(t,WHITESPACE);
3270                 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3271                 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3272                         char *facility;
3273                         Unit *u;
3274                         if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3275                                 continue;
3276                         if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3277                                 UnitDependency e;
3278                                 char *dep = NULL, *name, **j;
3279
3280                                 STRV_FOREACH (j, parsed+1) {
3281                                         if (*j[0]=='+') {
3282                                                 e = UNIT_WANTS;
3283                                                 name = *j+1;
3284                                         }
3285                                         else {
3286                                                 e = UNIT_REQUIRES;
3287                                                 name = *j;
3288                                         }
3289                                         if (sysv_translate_facility(name, NULL, &dep) < 0)
3290                                                 continue;
3291
3292                                         r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3293                                         free(dep);
3294                                 }
3295                         }
3296                         free(facility);
3297                 }
3298                 strv_free(parsed);
3299         }
3300 finish:
3301         if (f)
3302                 fclose(f);
3303
3304 }
3305 #endif
3306
3307 static int service_enumerate(Manager *m) {
3308         char **p;
3309         unsigned i;
3310         DIR *d = NULL;
3311         char *path = NULL, *fpath = NULL, *name = NULL;
3312         Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3313         Unit *service;
3314         Iterator j;
3315         int r;
3316
3317         assert(m);
3318
3319         if (m->running_as != MANAGER_SYSTEM)
3320                 return 0;
3321
3322         zero(runlevel_services);
3323
3324         STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3325                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3326                         struct dirent *de;
3327
3328                         free(path);
3329                         path = join(*p, "/", rcnd_table[i].path, NULL);
3330                         if (!path) {
3331                                 r = -ENOMEM;
3332                                 goto finish;
3333                         }
3334
3335                         if (d)
3336                                 closedir(d);
3337
3338                         if (!(d = opendir(path))) {
3339                                 if (errno != ENOENT)
3340                                         log_warning("opendir() failed on %s: %s", path, strerror(errno));
3341
3342                                 continue;
3343                         }
3344
3345                         while ((de = readdir(d))) {
3346                                 int a, b;
3347
3348                                 if (ignore_file(de->d_name))
3349                                         continue;
3350
3351                                 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3352                                         continue;
3353
3354                                 if (strlen(de->d_name) < 4)
3355                                         continue;
3356
3357                                 a = undecchar(de->d_name[1]);
3358                                 b = undecchar(de->d_name[2]);
3359
3360                                 if (a < 0 || b < 0)
3361                                         continue;
3362
3363                                 free(fpath);
3364                                 fpath = join(path, "/", de->d_name, NULL);
3365                                 if (!fpath) {
3366                                         r = -ENOMEM;
3367                                         goto finish;
3368                                 }
3369
3370                                 if (access(fpath, X_OK) < 0) {
3371
3372                                         if (errno != ENOENT)
3373                                                 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3374
3375                                         continue;
3376                                 }
3377
3378                                 free(name);
3379                                 if (!(name = sysv_translate_name(de->d_name + 3))) {
3380                                         r = -ENOMEM;
3381                                         goto finish;
3382                                 }
3383
3384                                 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3385                                         log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3386                                         continue;
3387                                 }
3388
3389                                 if (de->d_name[0] == 'S')  {
3390
3391                                         if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3392                                                 SERVICE(service)->sysv_start_priority_from_rcnd =
3393                                                         MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3394
3395                                                 SERVICE(service)->sysv_enabled = true;
3396                                         }
3397
3398                                         if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3399                                                 goto finish;
3400
3401                                         if ((r = set_put(runlevel_services[i], service)) < 0)
3402                                                 goto finish;
3403
3404                                 } else if (de->d_name[0] == 'K' &&
3405                                            (rcnd_table[i].type == RUNLEVEL_DOWN ||
3406                                             rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3407
3408                                         if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3409                                                 goto finish;
3410
3411                                         if ((r = set_put(shutdown_services, service)) < 0)
3412                                                 goto finish;
3413                                 }
3414                         }
3415                 }
3416
3417         /* Now we loaded all stubs and are aware of the lowest
3418         start-up priority for all services, not let's actually load
3419         the services, this will also tell us which services are
3420         actually native now */
3421         manager_dispatch_load_queue(m);
3422
3423         /* If this is a native service, rely on native ways to pull in
3424          * a service, don't pull it in via sysv rcN.d links. */
3425         for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3426                 SET_FOREACH(service, runlevel_services[i], j) {
3427                         service = unit_follow_merge(service);
3428
3429                         if (service->fragment_path)
3430                                 continue;
3431
3432                         if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3433                                 goto finish;
3434                 }
3435
3436         /* We honour K links only for halt/reboot. For the normal
3437          * runlevels we assume the stop jobs will be implicitly added
3438          * by the core logic. Also, we don't really distinguish here
3439          * between the runlevels 0 and 6 and just add them to the
3440          * special shutdown target. On SUSE the boot.d/ runlevel is
3441          * also used for shutdown, so we add links for that too to the
3442          * shutdown target.*/
3443         SET_FOREACH(service, shutdown_services, j) {
3444                 service = unit_follow_merge(service);
3445
3446                 if (service->fragment_path)
3447                         continue;
3448
3449                 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3450                         goto finish;
3451         }
3452
3453         r = 0;
3454
3455 #ifdef TARGET_SUSE
3456         sysv_facility_in_insserv_conf (m);
3457 #endif
3458
3459 finish:
3460         free(path);
3461         free(fpath);
3462         free(name);
3463
3464         for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3465                 set_free(runlevel_services[i]);
3466         set_free(shutdown_services);
3467
3468         if (d)
3469                 closedir(d);
3470
3471         return r;
3472 }
3473 #endif
3474
3475 static void service_bus_name_owner_change(
3476                 Unit *u,
3477                 const char *name,
3478                 const char *old_owner,
3479                 const char *new_owner) {
3480
3481         Service *s = SERVICE(u);
3482
3483         assert(s);
3484         assert(name);
3485
3486         assert(streq(s->bus_name, name));
3487         assert(old_owner || new_owner);
3488
3489         if (old_owner && new_owner)
3490                 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3491         else if (old_owner)
3492                 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3493         else
3494                 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3495
3496         s->bus_name_good = !!new_owner;
3497
3498         if (s->type == SERVICE_DBUS) {
3499
3500                 /* service_enter_running() will figure out what to
3501                  * do */
3502                 if (s->state == SERVICE_RUNNING)
3503                         service_enter_running(s, SERVICE_SUCCESS);
3504                 else if (s->state == SERVICE_START && new_owner)
3505                         service_enter_start_post(s);
3506
3507         } else if (new_owner &&
3508                    s->main_pid <= 0 &&
3509                    (s->state == SERVICE_START ||
3510                     s->state == SERVICE_START_POST ||
3511                     s->state == SERVICE_RUNNING ||
3512                     s->state == SERVICE_RELOAD)) {
3513
3514                 /* Try to acquire PID from bus service */
3515                 log_debug("Trying to acquire PID from D-Bus name...");
3516
3517                 bus_query_pid(u->manager, name);
3518         }
3519 }
3520
3521 static void service_bus_query_pid_done(
3522                 Unit *u,
3523                 const char *name,
3524                 pid_t pid) {
3525
3526         Service *s = SERVICE(u);
3527
3528         assert(s);
3529         assert(name);
3530
3531         log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3532
3533         if (s->main_pid <= 0 &&
3534             (s->state == SERVICE_START ||
3535              s->state == SERVICE_START_POST ||
3536              s->state == SERVICE_RUNNING ||
3537              s->state == SERVICE_RELOAD))
3538                 service_set_main_pid(s, pid);
3539 }
3540
3541 int service_set_socket_fd(Service *s, int fd, Socket *sock) {
3542
3543         assert(s);
3544         assert(fd >= 0);
3545
3546         /* This is called by the socket code when instantiating a new
3547          * service for a stream socket and the socket needs to be
3548          * configured. */
3549
3550         if (UNIT(s)->load_state != UNIT_LOADED)
3551                 return -EINVAL;
3552
3553         if (s->socket_fd >= 0)
3554                 return -EBUSY;
3555
3556         if (s->state != SERVICE_DEAD)
3557                 return -EAGAIN;
3558
3559         s->socket_fd = fd;
3560         s->got_socket_fd = true;
3561
3562         unit_ref_set(&s->accept_socket, UNIT(sock));
3563
3564         return unit_add_two_dependencies(UNIT(sock), UNIT_BEFORE, UNIT_TRIGGERS, UNIT(s), false);
3565 }
3566
3567 static void service_reset_failed(Unit *u) {
3568         Service *s = SERVICE(u);
3569
3570         assert(s);
3571
3572         if (s->state == SERVICE_FAILED)
3573                 service_set_state(s, SERVICE_DEAD);
3574
3575         s->result = SERVICE_SUCCESS;
3576         s->reload_result = SERVICE_SUCCESS;
3577 }
3578
3579 static bool service_need_daemon_reload(Unit *u) {
3580         Service *s = SERVICE(u);
3581
3582         assert(s);
3583
3584 #ifdef HAVE_SYSV_COMPAT
3585         if (s->sysv_path) {
3586                 struct stat st;
3587
3588                 zero(st);
3589                 if (stat(s->sysv_path, &st) < 0)
3590                         /* What, cannot access this anymore? */
3591                         return true;
3592
3593                 if (s->sysv_mtime > 0 &&
3594                     timespec_load(&st.st_mtim) != s->sysv_mtime)
3595                         return true;
3596         }
3597 #endif
3598
3599         return false;
3600 }
3601
3602 static int service_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
3603         Service *s = SERVICE(u);
3604         int r = 0;
3605         Set *pid_set = NULL;
3606
3607         assert(s);
3608
3609         if (s->main_pid <= 0 && who == KILL_MAIN) {
3610                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3611                 return -ESRCH;
3612         }
3613
3614         if (s->control_pid <= 0 && who == KILL_CONTROL) {
3615                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3616                 return -ESRCH;
3617         }
3618
3619         if (who == KILL_CONTROL || who == KILL_ALL)
3620                 if (s->control_pid > 0)
3621                         if (kill(s->control_pid, signo) < 0)
3622                                 r = -errno;
3623
3624         if (who == KILL_MAIN || who == KILL_ALL)
3625                 if (s->main_pid > 0)
3626                         if (kill(s->main_pid, signo) < 0)
3627                                 r = -errno;
3628
3629         if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
3630                 int q;
3631
3632                 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
3633                         return -ENOMEM;
3634
3635                 /* Exclude the control/main pid from being killed via the cgroup */
3636                 if (s->control_pid > 0)
3637                         if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
3638                                 r = q;
3639                                 goto finish;
3640                         }
3641
3642                 if (s->main_pid > 0)
3643                         if ((q = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0) {
3644                                 r = q;
3645                                 goto finish;
3646                         }
3647
3648                 if ((q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, pid_set)) < 0)
3649                         if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3650                                 r = q;
3651         }
3652
3653 finish:
3654         if (pid_set)
3655                 set_free(pid_set);
3656
3657         return r;
3658 }
3659
3660 static const char* const service_state_table[_SERVICE_STATE_MAX] = {
3661         [SERVICE_DEAD] = "dead",
3662         [SERVICE_START_PRE] = "start-pre",
3663         [SERVICE_START] = "start",
3664         [SERVICE_START_POST] = "start-post",
3665         [SERVICE_RUNNING] = "running",
3666         [SERVICE_EXITED] = "exited",
3667         [SERVICE_RELOAD] = "reload",
3668         [SERVICE_STOP] = "stop",
3669         [SERVICE_STOP_SIGTERM] = "stop-sigterm",
3670         [SERVICE_STOP_SIGKILL] = "stop-sigkill",
3671         [SERVICE_STOP_POST] = "stop-post",
3672         [SERVICE_FINAL_SIGTERM] = "final-sigterm",
3673         [SERVICE_FINAL_SIGKILL] = "final-sigkill",
3674         [SERVICE_FAILED] = "failed",
3675         [SERVICE_AUTO_RESTART] = "auto-restart",
3676 };
3677
3678 DEFINE_STRING_TABLE_LOOKUP(service_state, ServiceState);
3679
3680 static const char* const service_restart_table[_SERVICE_RESTART_MAX] = {
3681         [SERVICE_RESTART_NO] = "no",
3682         [SERVICE_RESTART_ON_SUCCESS] = "on-success",
3683         [SERVICE_RESTART_ON_FAILURE] = "on-failure",
3684         [SERVICE_RESTART_ON_ABORT] = "on-abort",
3685         [SERVICE_RESTART_ALWAYS] = "always"
3686 };
3687
3688 DEFINE_STRING_TABLE_LOOKUP(service_restart, ServiceRestart);
3689
3690 static const char* const service_type_table[_SERVICE_TYPE_MAX] = {
3691         [SERVICE_SIMPLE] = "simple",
3692         [SERVICE_FORKING] = "forking",
3693         [SERVICE_ONESHOT] = "oneshot",
3694         [SERVICE_DBUS] = "dbus",
3695         [SERVICE_NOTIFY] = "notify"
3696 };
3697
3698 DEFINE_STRING_TABLE_LOOKUP(service_type, ServiceType);
3699
3700 static const char* const service_exec_command_table[_SERVICE_EXEC_COMMAND_MAX] = {
3701         [SERVICE_EXEC_START_PRE] = "ExecStartPre",
3702         [SERVICE_EXEC_START] = "ExecStart",
3703         [SERVICE_EXEC_START_POST] = "ExecStartPost",
3704         [SERVICE_EXEC_RELOAD] = "ExecReload",
3705         [SERVICE_EXEC_STOP] = "ExecStop",
3706         [SERVICE_EXEC_STOP_POST] = "ExecStopPost",
3707 };
3708
3709 DEFINE_STRING_TABLE_LOOKUP(service_exec_command, ServiceExecCommand);
3710
3711 static const char* const notify_access_table[_NOTIFY_ACCESS_MAX] = {
3712         [NOTIFY_NONE] = "none",
3713         [NOTIFY_MAIN] = "main",
3714         [NOTIFY_ALL] = "all"
3715 };
3716
3717 DEFINE_STRING_TABLE_LOOKUP(notify_access, NotifyAccess);
3718
3719 static const char* const service_result_table[_SERVICE_RESULT_MAX] = {
3720         [SERVICE_SUCCESS] = "success",
3721         [SERVICE_FAILURE_RESOURCES] = "resources",
3722         [SERVICE_FAILURE_TIMEOUT] = "timeout",
3723         [SERVICE_FAILURE_EXIT_CODE] = "exit-code",
3724         [SERVICE_FAILURE_SIGNAL] = "signal",
3725         [SERVICE_FAILURE_CORE_DUMP] = "core-dump",
3726         [SERVICE_FAILURE_WATCHDOG] = "watchdog"
3727 };
3728
3729 DEFINE_STRING_TABLE_LOOKUP(service_result, ServiceResult);
3730
3731 static const char* const start_limit_action_table[_SERVICE_START_LIMIT_MAX] = {
3732         [SERVICE_START_LIMIT_NONE] = "none",
3733         [SERVICE_START_LIMIT_REBOOT] = "reboot",
3734         [SERVICE_START_LIMIT_REBOOT_FORCE] = "reboot-force",
3735         [SERVICE_START_LIMIT_REBOOT_IMMEDIATE] = "reboot-immediate"
3736 };
3737 DEFINE_STRING_TABLE_LOOKUP(start_limit_action, StartLimitAction);
3738
3739 const UnitVTable service_vtable = {
3740         .suffix = ".service",
3741         .object_size = sizeof(Service),
3742         .sections =
3743                 "Unit\0"
3744                 "Service\0"
3745                 "Install\0",
3746         .show_status = true,
3747
3748         .init = service_init,
3749         .done = service_done,
3750         .load = service_load,
3751
3752         .coldplug = service_coldplug,
3753
3754         .dump = service_dump,
3755
3756         .start = service_start,
3757         .stop = service_stop,
3758         .reload = service_reload,
3759
3760         .can_reload = service_can_reload,
3761
3762         .kill = service_kill,
3763
3764         .serialize = service_serialize,
3765         .deserialize_item = service_deserialize_item,
3766
3767         .active_state = service_active_state,
3768         .sub_state_to_string = service_sub_state_to_string,
3769
3770         .check_gc = service_check_gc,
3771         .check_snapshot = service_check_snapshot,
3772
3773         .sigchld_event = service_sigchld_event,
3774         .timer_event = service_timer_event,
3775         .fd_event = service_fd_event,
3776
3777         .reset_failed = service_reset_failed,
3778
3779         .need_daemon_reload = service_need_daemon_reload,
3780
3781         .cgroup_notify_empty = service_cgroup_notify_event,
3782         .notify_message = service_notify_message,
3783
3784         .bus_name_owner_change = service_bus_name_owner_change,
3785         .bus_query_pid_done = service_bus_query_pid_done,
3786
3787         .bus_interface = "org.freedesktop.systemd1.Service",
3788         .bus_message_handler = bus_service_message_handler,
3789         .bus_invalidating_properties =  bus_service_invalidating_properties,
3790
3791 #ifdef HAVE_SYSV_COMPAT
3792         .enumerate = service_enumerate
3793 #endif
3794 };