src/core/service.c

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