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