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