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