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