chiark / gitweb /
util: rename join() to strjoin()
[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
1287         return service_verify(s);
1288 }
1289
1290 static void service_dump(Unit *u, FILE *f, const char *prefix) {
1291
1292         ServiceExecCommand c;
1293         Service *s = SERVICE(u);
1294         const char *prefix2;
1295         char *p2;
1296
1297         assert(s);
1298
1299         p2 = strappend(prefix, "\t");
1300         prefix2 = p2 ? p2 : prefix;
1301
1302         fprintf(f,
1303                 "%sService State: %s\n"
1304                 "%sResult: %s\n"
1305                 "%sReload Result: %s\n"
1306                 "%sPermissionsStartOnly: %s\n"
1307                 "%sRootDirectoryStartOnly: %s\n"
1308                 "%sRemainAfterExit: %s\n"
1309                 "%sGuessMainPID: %s\n"
1310                 "%sType: %s\n"
1311                 "%sRestart: %s\n"
1312                 "%sNotifyAccess: %s\n",
1313                 prefix, service_state_to_string(s->state),
1314                 prefix, service_result_to_string(s->result),
1315                 prefix, service_result_to_string(s->reload_result),
1316                 prefix, yes_no(s->permissions_start_only),
1317                 prefix, yes_no(s->root_directory_start_only),
1318                 prefix, yes_no(s->remain_after_exit),
1319                 prefix, yes_no(s->guess_main_pid),
1320                 prefix, service_type_to_string(s->type),
1321                 prefix, service_restart_to_string(s->restart),
1322                 prefix, notify_access_to_string(s->notify_access));
1323
1324         if (s->control_pid > 0)
1325                 fprintf(f,
1326                         "%sControl PID: %lu\n",
1327                         prefix, (unsigned long) s->control_pid);
1328
1329         if (s->main_pid > 0)
1330                 fprintf(f,
1331                         "%sMain PID: %lu\n"
1332                         "%sMain PID Known: %s\n"
1333                         "%sMain PID Alien: %s\n",
1334                         prefix, (unsigned long) s->main_pid,
1335                         prefix, yes_no(s->main_pid_known),
1336                         prefix, yes_no(s->main_pid_alien));
1337
1338         if (s->pid_file)
1339                 fprintf(f,
1340                         "%sPIDFile: %s\n",
1341                         prefix, s->pid_file);
1342
1343         if (s->bus_name)
1344                 fprintf(f,
1345                         "%sBusName: %s\n"
1346                         "%sBus Name Good: %s\n",
1347                         prefix, s->bus_name,
1348                         prefix, yes_no(s->bus_name_good));
1349
1350         exec_context_dump(&s->exec_context, f, prefix);
1351
1352         for (c = 0; c < _SERVICE_EXEC_COMMAND_MAX; c++) {
1353
1354                 if (!s->exec_command[c])
1355                         continue;
1356
1357                 fprintf(f, "%s-> %s:\n",
1358                         prefix, service_exec_command_to_string(c));
1359
1360                 exec_command_dump_list(s->exec_command[c], f, prefix2);
1361         }
1362
1363 #ifdef HAVE_SYSV_COMPAT
1364         if (s->is_sysv)
1365                 fprintf(f,
1366                         "%sSysV Init Script has LSB Header: %s\n"
1367                         "%sSysVEnabled: %s\n",
1368                         prefix, yes_no(s->sysv_has_lsb),
1369                         prefix, yes_no(s->sysv_enabled));
1370
1371         if (s->sysv_start_priority >= 0)
1372                 fprintf(f,
1373                         "%sSysVStartPriority: %i\n",
1374                         prefix, s->sysv_start_priority);
1375
1376         if (s->sysv_runlevels)
1377                 fprintf(f, "%sSysVRunLevels: %s\n",
1378                         prefix, s->sysv_runlevels);
1379 #endif
1380
1381         if (s->fsck_passno > 0)
1382                 fprintf(f,
1383                         "%sFsckPassNo: %i\n",
1384                         prefix, s->fsck_passno);
1385
1386         if (s->status_text)
1387                 fprintf(f, "%sStatus Text: %s\n",
1388                         prefix, s->status_text);
1389
1390         free(p2);
1391 }
1392
1393 static int service_load_pid_file(Service *s, bool may_warn) {
1394         char *k;
1395         int r;
1396         pid_t pid;
1397
1398         assert(s);
1399
1400         if (!s->pid_file)
1401                 return -ENOENT;
1402
1403         if ((r = read_one_line_file(s->pid_file, &k)) < 0) {
1404                 if (may_warn)
1405                         log_info("PID file %s not readable (yet?) after %s.",
1406                                  s->pid_file, service_state_to_string(s->state));
1407                 return r;
1408         }
1409
1410         r = parse_pid(k, &pid);
1411         free(k);
1412
1413         if (r < 0)
1414                 return r;
1415
1416         if (kill(pid, 0) < 0 && errno != EPERM) {
1417                 if (may_warn)
1418                         log_info("PID %lu read from file %s does not exist.",
1419                                  (unsigned long) pid, s->pid_file);
1420                 return -ESRCH;
1421         }
1422
1423         if (s->main_pid_known) {
1424                 if (pid == s->main_pid)
1425                         return 0;
1426
1427                 log_debug("Main PID changing: %lu -> %lu",
1428                           (unsigned long) s->main_pid, (unsigned long) pid);
1429                 service_unwatch_main_pid(s);
1430                 s->main_pid_known = false;
1431         } else
1432                 log_debug("Main PID loaded: %lu", (unsigned long) pid);
1433
1434         if ((r = service_set_main_pid(s, pid)) < 0)
1435                 return r;
1436
1437         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1438                 /* FIXME: we need to do something here */
1439                 return r;
1440
1441         return 0;
1442 }
1443
1444 static int service_search_main_pid(Service *s) {
1445         pid_t pid;
1446         int r;
1447
1448         assert(s);
1449
1450         /* If we know it anyway, don't ever fallback to unreliable
1451          * heuristics */
1452         if (s->main_pid_known)
1453                 return 0;
1454
1455         if (!s->guess_main_pid)
1456                 return 0;
1457
1458         assert(s->main_pid <= 0);
1459
1460         if ((pid = cgroup_bonding_search_main_pid_list(UNIT(s)->cgroup_bondings)) <= 0)
1461                 return -ENOENT;
1462
1463         log_debug("Main PID guessed: %lu", (unsigned long) pid);
1464         if ((r = service_set_main_pid(s, pid)) < 0)
1465                 return r;
1466
1467         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1468                 /* FIXME: we need to do something here */
1469                 return r;
1470
1471         return 0;
1472 }
1473
1474 static void service_notify_sockets_dead(Service *s, bool failed_permanent) {
1475         Iterator i;
1476         Unit *u;
1477
1478         assert(s);
1479
1480         /* Notifies all our sockets when we die */
1481
1482         if (s->socket_fd >= 0)
1483                 return;
1484
1485         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i)
1486                 if (u->type == UNIT_SOCKET)
1487                         socket_notify_service_dead(SOCKET(u), failed_permanent);
1488
1489         return;
1490 }
1491
1492 static void service_set_state(Service *s, ServiceState state) {
1493         ServiceState old_state;
1494         const UnitActiveState *table;
1495         assert(s);
1496
1497         table = s->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
1498
1499         old_state = s->state;
1500         s->state = state;
1501
1502         service_unwatch_pid_file(s);
1503
1504         if (state != SERVICE_START_PRE &&
1505             state != SERVICE_START &&
1506             state != SERVICE_START_POST &&
1507             state != SERVICE_RELOAD &&
1508             state != SERVICE_STOP &&
1509             state != SERVICE_STOP_SIGTERM &&
1510             state != SERVICE_STOP_SIGKILL &&
1511             state != SERVICE_STOP_POST &&
1512             state != SERVICE_FINAL_SIGTERM &&
1513             state != SERVICE_FINAL_SIGKILL &&
1514             state != SERVICE_AUTO_RESTART)
1515                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1516
1517         if (state != SERVICE_START &&
1518             state != SERVICE_START_POST &&
1519             state != SERVICE_RUNNING &&
1520             state != SERVICE_RELOAD &&
1521             state != SERVICE_STOP &&
1522             state != SERVICE_STOP_SIGTERM &&
1523             state != SERVICE_STOP_SIGKILL) {
1524                 service_unwatch_main_pid(s);
1525                 s->main_command = NULL;
1526         }
1527
1528         if (state != SERVICE_START_PRE &&
1529             state != SERVICE_START &&
1530             state != SERVICE_START_POST &&
1531             state != SERVICE_RELOAD &&
1532             state != SERVICE_STOP &&
1533             state != SERVICE_STOP_SIGTERM &&
1534             state != SERVICE_STOP_SIGKILL &&
1535             state != SERVICE_STOP_POST &&
1536             state != SERVICE_FINAL_SIGTERM &&
1537             state != SERVICE_FINAL_SIGKILL) {
1538                 service_unwatch_control_pid(s);
1539                 s->control_command = NULL;
1540                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
1541         }
1542
1543         if (state == SERVICE_DEAD ||
1544             state == SERVICE_STOP ||
1545             state == SERVICE_STOP_SIGTERM ||
1546             state == SERVICE_STOP_SIGKILL ||
1547             state == SERVICE_STOP_POST ||
1548             state == SERVICE_FINAL_SIGTERM ||
1549             state == SERVICE_FINAL_SIGKILL ||
1550             state == SERVICE_FAILED ||
1551             state == SERVICE_AUTO_RESTART)
1552                 service_notify_sockets_dead(s, false);
1553
1554         if (state != SERVICE_START_PRE &&
1555             state != SERVICE_START &&
1556             state != SERVICE_START_POST &&
1557             state != SERVICE_RUNNING &&
1558             state != SERVICE_RELOAD &&
1559             state != SERVICE_STOP &&
1560             state != SERVICE_STOP_SIGTERM &&
1561             state != SERVICE_STOP_SIGKILL &&
1562             state != SERVICE_STOP_POST &&
1563             state != SERVICE_FINAL_SIGTERM &&
1564             state != SERVICE_FINAL_SIGKILL &&
1565             !(state == SERVICE_DEAD && UNIT(s)->job)) {
1566                 service_close_socket_fd(s);
1567                 service_connection_unref(s);
1568         }
1569
1570         if (state == SERVICE_STOP)
1571                 service_stop_watchdog(s);
1572
1573         /* For the inactive states unit_notify() will trim the cgroup,
1574          * but for exit we have to do that ourselves... */
1575         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
1576                 cgroup_bonding_trim_list(UNIT(s)->cgroup_bondings, true);
1577
1578         if (old_state != state)
1579                 log_debug("%s changed %s -> %s", UNIT(s)->id, service_state_to_string(old_state), service_state_to_string(state));
1580
1581         unit_notify(UNIT(s), table[old_state], table[state], s->reload_result == SERVICE_SUCCESS);
1582         s->reload_result = SERVICE_SUCCESS;
1583 }
1584
1585 static int service_coldplug(Unit *u) {
1586         Service *s = SERVICE(u);
1587         int r;
1588
1589         assert(s);
1590         assert(s->state == SERVICE_DEAD);
1591
1592         if (s->deserialized_state != s->state) {
1593
1594                 if (s->deserialized_state == SERVICE_START_PRE ||
1595                     s->deserialized_state == SERVICE_START ||
1596                     s->deserialized_state == SERVICE_START_POST ||
1597                     s->deserialized_state == SERVICE_RELOAD ||
1598                     s->deserialized_state == SERVICE_STOP ||
1599                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1600                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1601                     s->deserialized_state == SERVICE_STOP_POST ||
1602                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1603                     s->deserialized_state == SERVICE_FINAL_SIGKILL ||
1604                     s->deserialized_state == SERVICE_AUTO_RESTART) {
1605
1606                         if (s->deserialized_state == SERVICE_AUTO_RESTART || s->timeout_usec > 0) {
1607                                 usec_t k;
1608
1609                                 k = s->deserialized_state == SERVICE_AUTO_RESTART ? s->restart_usec : s->timeout_usec;
1610
1611                                 if ((r = unit_watch_timer(UNIT(s), k, &s->timer_watch)) < 0)
1612                                         return r;
1613                         }
1614                 }
1615
1616                 if ((s->deserialized_state == SERVICE_START &&
1617                      (s->type == SERVICE_FORKING ||
1618                       s->type == SERVICE_DBUS ||
1619                       s->type == SERVICE_ONESHOT ||
1620                       s->type == SERVICE_NOTIFY)) ||
1621                     s->deserialized_state == SERVICE_START_POST ||
1622                     s->deserialized_state == SERVICE_RUNNING ||
1623                     s->deserialized_state == SERVICE_RELOAD ||
1624                     s->deserialized_state == SERVICE_STOP ||
1625                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1626                     s->deserialized_state == SERVICE_STOP_SIGKILL)
1627                         if (s->main_pid > 0)
1628                                 if ((r = unit_watch_pid(UNIT(s), s->main_pid)) < 0)
1629                                         return r;
1630
1631                 if (s->deserialized_state == SERVICE_START_PRE ||
1632                     s->deserialized_state == SERVICE_START ||
1633                     s->deserialized_state == SERVICE_START_POST ||
1634                     s->deserialized_state == SERVICE_RELOAD ||
1635                     s->deserialized_state == SERVICE_STOP ||
1636                     s->deserialized_state == SERVICE_STOP_SIGTERM ||
1637                     s->deserialized_state == SERVICE_STOP_SIGKILL ||
1638                     s->deserialized_state == SERVICE_STOP_POST ||
1639                     s->deserialized_state == SERVICE_FINAL_SIGTERM ||
1640                     s->deserialized_state == SERVICE_FINAL_SIGKILL)
1641                         if (s->control_pid > 0)
1642                                 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1643                                         return r;
1644
1645                 if (s->deserialized_state == SERVICE_START_POST ||
1646                     s->deserialized_state == SERVICE_RUNNING)
1647                         service_handle_watchdog(s);
1648
1649                 service_set_state(s, s->deserialized_state);
1650         }
1651         return 0;
1652 }
1653
1654 static int service_collect_fds(Service *s, int **fds, unsigned *n_fds) {
1655         Iterator i;
1656         int r;
1657         int *rfds = NULL;
1658         unsigned rn_fds = 0;
1659         Unit *u;
1660
1661         assert(s);
1662         assert(fds);
1663         assert(n_fds);
1664
1665         if (s->socket_fd >= 0)
1666                 return 0;
1667
1668         SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
1669                 int *cfds;
1670                 unsigned cn_fds;
1671                 Socket *sock;
1672
1673                 if (u->type != UNIT_SOCKET)
1674                         continue;
1675
1676                 sock = SOCKET(u);
1677
1678                 if ((r = socket_collect_fds(sock, &cfds, &cn_fds)) < 0)
1679                         goto fail;
1680
1681                 if (!cfds)
1682                         continue;
1683
1684                 if (!rfds) {
1685                         rfds = cfds;
1686                         rn_fds = cn_fds;
1687                 } else {
1688                         int *t;
1689
1690                         if (!(t = new(int, rn_fds+cn_fds))) {
1691                                 free(cfds);
1692                                 r = -ENOMEM;
1693                                 goto fail;
1694                         }
1695
1696                         memcpy(t, rfds, rn_fds * sizeof(int));
1697                         memcpy(t+rn_fds, cfds, cn_fds * sizeof(int));
1698                         free(rfds);
1699                         free(cfds);
1700
1701                         rfds = t;
1702                         rn_fds = rn_fds+cn_fds;
1703                 }
1704         }
1705
1706         *fds = rfds;
1707         *n_fds = rn_fds;
1708
1709         return 0;
1710
1711 fail:
1712         free(rfds);
1713
1714         return r;
1715 }
1716
1717 static int service_spawn(
1718                 Service *s,
1719                 ExecCommand *c,
1720                 bool timeout,
1721                 bool pass_fds,
1722                 bool apply_permissions,
1723                 bool apply_chroot,
1724                 bool apply_tty_stdin,
1725                 bool set_notify_socket,
1726                 bool is_control,
1727                 pid_t *_pid) {
1728
1729         pid_t pid;
1730         int r;
1731         int *fds = NULL, *fdsbuf = NULL;
1732         unsigned n_fds = 0, n_env = 0;
1733         char **argv = NULL, **final_env = NULL, **our_env = NULL;
1734
1735         assert(s);
1736         assert(c);
1737         assert(_pid);
1738
1739         if (pass_fds ||
1740             s->exec_context.std_input == EXEC_INPUT_SOCKET ||
1741             s->exec_context.std_output == EXEC_OUTPUT_SOCKET ||
1742             s->exec_context.std_error == EXEC_OUTPUT_SOCKET) {
1743
1744                 if (s->socket_fd >= 0) {
1745                         fds = &s->socket_fd;
1746                         n_fds = 1;
1747                 } else {
1748                         if ((r = service_collect_fds(s, &fdsbuf, &n_fds)) < 0)
1749                                 goto fail;
1750
1751                         fds = fdsbuf;
1752                 }
1753         }
1754
1755         if (timeout && s->timeout_usec) {
1756                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1757                         goto fail;
1758         } else
1759                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1760
1761         if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1762                 r = -ENOMEM;
1763                 goto fail;
1764         }
1765
1766         if (!(our_env = new0(char*, 4))) {
1767                 r = -ENOMEM;
1768                 goto fail;
1769         }
1770
1771         if (set_notify_socket)
1772                 if (asprintf(our_env + n_env++, "NOTIFY_SOCKET=%s", UNIT(s)->manager->notify_socket) < 0) {
1773                         r = -ENOMEM;
1774                         goto fail;
1775                 }
1776
1777         if (s->main_pid > 0)
1778                 if (asprintf(our_env + n_env++, "MAINPID=%lu", (unsigned long) s->main_pid) < 0) {
1779                         r = -ENOMEM;
1780                         goto fail;
1781                 }
1782
1783         if (s->watchdog_usec > 0)
1784                 if (asprintf(our_env + n_env++, "WATCHDOG_USEC=%llu", (unsigned long long) s->watchdog_usec) < 0) {
1785                         r = -ENOMEM;
1786                         goto fail;
1787                 }
1788
1789         if (!(final_env = strv_env_merge(2,
1790                                          UNIT(s)->manager->environment,
1791                                          our_env,
1792                                          NULL))) {
1793                 r = -ENOMEM;
1794                 goto fail;
1795         }
1796
1797         r = exec_spawn(c,
1798                        argv,
1799                        &s->exec_context,
1800                        fds, n_fds,
1801                        final_env,
1802                        apply_permissions,
1803                        apply_chroot,
1804                        apply_tty_stdin,
1805                        UNIT(s)->manager->confirm_spawn,
1806                        UNIT(s)->cgroup_bondings,
1807                        UNIT(s)->cgroup_attributes,
1808                        is_control ? "control" : NULL,
1809                        UNIT(s)->id,
1810                        s->type == SERVICE_IDLE ? UNIT(s)->manager->idle_pipe : NULL,
1811                        &pid);
1812
1813         if (r < 0)
1814                 goto fail;
1815
1816
1817         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1818                 /* FIXME: we need to do something here */
1819                 goto fail;
1820
1821         free(fdsbuf);
1822         strv_free(argv);
1823         strv_free(our_env);
1824         strv_free(final_env);
1825
1826         *_pid = pid;
1827
1828         return 0;
1829
1830 fail:
1831         free(fdsbuf);
1832         strv_free(argv);
1833         strv_free(our_env);
1834         strv_free(final_env);
1835
1836         if (timeout)
1837                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1838
1839         return r;
1840 }
1841
1842 static int main_pid_good(Service *s) {
1843         assert(s);
1844
1845         /* Returns 0 if the pid is dead, 1 if it is good, -1 if we
1846          * don't know */
1847
1848         /* If we know the pid file, then lets just check if it is
1849          * still valid */
1850         if (s->main_pid_known) {
1851
1852                 /* If it's an alien child let's check if it is still
1853                  * alive ... */
1854                 if (s->main_pid_alien)
1855                         return kill(s->main_pid, 0) >= 0 || errno != ESRCH;
1856
1857                 /* .. otherwise assume we'll get a SIGCHLD for it,
1858                  * which we really should wait for to collect exit
1859                  * status and code */
1860                 return s->main_pid > 0;
1861         }
1862
1863         /* We don't know the pid */
1864         return -EAGAIN;
1865 }
1866
1867 static int control_pid_good(Service *s) {
1868         assert(s);
1869
1870         return s->control_pid > 0;
1871 }
1872
1873 static int cgroup_good(Service *s) {
1874         int r;
1875
1876         assert(s);
1877
1878         if ((r = cgroup_bonding_is_empty_list(UNIT(s)->cgroup_bondings)) < 0)
1879                 return r;
1880
1881         return !r;
1882 }
1883
1884 static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart) {
1885         int r;
1886         assert(s);
1887
1888         if (f != SERVICE_SUCCESS)
1889                 s->result = f;
1890
1891         service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
1892
1893         if (allow_restart &&
1894             !s->forbid_restart &&
1895             (s->restart == SERVICE_RESTART_ALWAYS ||
1896              (s->restart == SERVICE_RESTART_ON_SUCCESS && s->result == SERVICE_SUCCESS) ||
1897              (s->restart == SERVICE_RESTART_ON_FAILURE && s->result != SERVICE_SUCCESS) ||
1898              (s->restart == SERVICE_RESTART_ON_ABORT && (s->result == SERVICE_FAILURE_SIGNAL ||
1899                                                          s->result == SERVICE_FAILURE_CORE_DUMP)))) {
1900
1901                 r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch);
1902                 if (r < 0)
1903                         goto fail;
1904
1905                 service_set_state(s, SERVICE_AUTO_RESTART);
1906         }
1907
1908         s->forbid_restart = false;
1909
1910         return;
1911
1912 fail:
1913         log_warning("%s failed to run install restart timer: %s", UNIT(s)->id, strerror(-r));
1914         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
1915 }
1916
1917 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f);
1918
1919 static void service_enter_stop_post(Service *s, ServiceResult f) {
1920         int r;
1921         assert(s);
1922
1923         if (f != SERVICE_SUCCESS)
1924                 s->result = f;
1925
1926         service_unwatch_control_pid(s);
1927
1928         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP_POST])) {
1929                 s->control_command_id = SERVICE_EXEC_STOP_POST;
1930
1931                 r = service_spawn(s,
1932                                   s->control_command,
1933                                   true,
1934                                   false,
1935                                   !s->permissions_start_only,
1936                                   !s->root_directory_start_only,
1937                                   true,
1938                                   false,
1939                                   true,
1940                                   &s->control_pid);
1941                 if (r < 0)
1942                         goto fail;
1943
1944
1945                 service_set_state(s, SERVICE_STOP_POST);
1946         } else
1947                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_SUCCESS);
1948
1949         return;
1950
1951 fail:
1952         log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1953         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
1954 }
1955
1956 static void service_enter_signal(Service *s, ServiceState state, ServiceResult f) {
1957         int r;
1958         Set *pid_set = NULL;
1959         bool wait_for_exit = false;
1960
1961         assert(s);
1962
1963         if (f != SERVICE_SUCCESS)
1964                 s->result = f;
1965
1966         if (s->exec_context.kill_mode != KILL_NONE) {
1967                 int sig = (state == SERVICE_STOP_SIGTERM || state == SERVICE_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1968
1969                 if (s->main_pid > 0) {
1970                         if (kill_and_sigcont(s->main_pid, sig) < 0 && errno != ESRCH)
1971                                 log_warning("Failed to kill main process %li: %m", (long) s->main_pid);
1972                         else
1973                                 wait_for_exit = !s->main_pid_alien;
1974                 }
1975
1976                 if (s->control_pid > 0) {
1977                         if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1978                                 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1979                         else
1980                                 wait_for_exit = true;
1981                 }
1982
1983                 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1984
1985                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1986                                 r = -ENOMEM;
1987                                 goto fail;
1988                         }
1989
1990                         /* Exclude the main/control pids from being killed via the cgroup */
1991                         if (s->main_pid > 0)
1992                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->main_pid))) < 0)
1993                                         goto fail;
1994
1995                         if (s->control_pid > 0)
1996                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1997                                         goto fail;
1998
1999                         r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
2000                         if (r < 0) {
2001                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2002                                         log_warning("Failed to kill control group: %s", strerror(-r));
2003                         } else if (r > 0)
2004                                 wait_for_exit = true;
2005
2006                         set_free(pid_set);
2007                         pid_set = NULL;
2008                 }
2009         }
2010
2011         if (wait_for_exit) {
2012                 if (s->timeout_usec > 0)
2013                         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
2014                                 goto fail;
2015
2016                 service_set_state(s, state);
2017         } else if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2018                 service_enter_stop_post(s, SERVICE_SUCCESS);
2019         else
2020                 service_enter_dead(s, SERVICE_SUCCESS, true);
2021
2022         return;
2023
2024 fail:
2025         log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
2026
2027         if (state == SERVICE_STOP_SIGTERM || state == SERVICE_STOP_SIGKILL)
2028                 service_enter_stop_post(s, SERVICE_FAILURE_RESOURCES);
2029         else
2030                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2031
2032         if (pid_set)
2033                 set_free(pid_set);
2034 }
2035
2036 static void service_enter_stop(Service *s, ServiceResult f) {
2037         int r;
2038
2039         assert(s);
2040
2041         if (f != SERVICE_SUCCESS)
2042                 s->result = f;
2043
2044         service_unwatch_control_pid(s);
2045
2046         if ((s->control_command = s->exec_command[SERVICE_EXEC_STOP])) {
2047                 s->control_command_id = SERVICE_EXEC_STOP;
2048
2049                 r = service_spawn(s,
2050                                   s->control_command,
2051                                   true,
2052                                   false,
2053                                   !s->permissions_start_only,
2054                                   !s->root_directory_start_only,
2055                                   false,
2056                                   false,
2057                                   true,
2058                                   &s->control_pid);
2059                 if (r < 0)
2060                         goto fail;
2061
2062                 service_set_state(s, SERVICE_STOP);
2063         } else
2064                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2065
2066         return;
2067
2068 fail:
2069         log_warning("%s failed to run 'stop' task: %s", UNIT(s)->id, strerror(-r));
2070         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2071 }
2072
2073 static void service_enter_running(Service *s, ServiceResult f) {
2074         int main_pid_ok, cgroup_ok;
2075         assert(s);
2076
2077         if (f != SERVICE_SUCCESS)
2078                 s->result = f;
2079
2080         main_pid_ok = main_pid_good(s);
2081         cgroup_ok = cgroup_good(s);
2082
2083         if ((main_pid_ok > 0 || (main_pid_ok < 0 && cgroup_ok != 0)) &&
2084             (s->bus_name_good || s->type != SERVICE_DBUS))
2085                 service_set_state(s, SERVICE_RUNNING);
2086         else if (s->remain_after_exit)
2087                 service_set_state(s, SERVICE_EXITED);
2088         else
2089                 service_enter_stop(s, SERVICE_SUCCESS);
2090 }
2091
2092 static void service_enter_start_post(Service *s) {
2093         int r;
2094         assert(s);
2095
2096         service_unwatch_control_pid(s);
2097
2098         if (s->watchdog_usec > 0)
2099                 service_reset_watchdog(s);
2100
2101         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_POST])) {
2102                 s->control_command_id = SERVICE_EXEC_START_POST;
2103
2104                 r = service_spawn(s,
2105                                   s->control_command,
2106                                   true,
2107                                   false,
2108                                   !s->permissions_start_only,
2109                                   !s->root_directory_start_only,
2110                                   false,
2111                                   false,
2112                                   true,
2113                                   &s->control_pid);
2114                 if (r < 0)
2115                         goto fail;
2116
2117                 service_set_state(s, SERVICE_START_POST);
2118         } else
2119                 service_enter_running(s, SERVICE_SUCCESS);
2120
2121         return;
2122
2123 fail:
2124         log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
2125         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2126 }
2127
2128 static void service_enter_start(Service *s) {
2129         pid_t pid;
2130         int r;
2131         ExecCommand *c;
2132
2133         assert(s);
2134
2135         assert(s->exec_command[SERVICE_EXEC_START]);
2136         assert(!s->exec_command[SERVICE_EXEC_START]->command_next || s->type == SERVICE_ONESHOT);
2137
2138         if (s->type == SERVICE_FORKING)
2139                 service_unwatch_control_pid(s);
2140         else
2141                 service_unwatch_main_pid(s);
2142
2143         /* We want to ensure that nobody leaks processes from
2144          * START_PRE here, so let's go on a killing spree, People
2145          * should not spawn long running processes from START_PRE. */
2146         cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2147
2148         if (s->type == SERVICE_FORKING) {
2149                 s->control_command_id = SERVICE_EXEC_START;
2150                 c = s->control_command = s->exec_command[SERVICE_EXEC_START];
2151
2152                 s->main_command = NULL;
2153         } else {
2154                 s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2155                 s->control_command = NULL;
2156
2157                 c = s->main_command = s->exec_command[SERVICE_EXEC_START];
2158         }
2159
2160         r = service_spawn(s,
2161                           c,
2162                           s->type == SERVICE_FORKING || s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY || s->type == SERVICE_ONESHOT,
2163                           true,
2164                           true,
2165                           true,
2166                           true,
2167                           s->notify_access != NOTIFY_NONE,
2168                           false,
2169                           &pid);
2170         if (r < 0)
2171                 goto fail;
2172
2173         if (s->type == SERVICE_SIMPLE || s->type == SERVICE_IDLE) {
2174                 /* For simple services we immediately start
2175                  * the START_POST binaries. */
2176
2177                 service_set_main_pid(s, pid);
2178                 service_enter_start_post(s);
2179
2180         } else  if (s->type == SERVICE_FORKING) {
2181
2182                 /* For forking services we wait until the start
2183                  * process exited. */
2184
2185                 s->control_pid = pid;
2186                 service_set_state(s, SERVICE_START);
2187
2188         } else if (s->type == SERVICE_ONESHOT ||
2189                    s->type == SERVICE_DBUS ||
2190                    s->type == SERVICE_NOTIFY) {
2191
2192                 /* For oneshot services we wait until the start
2193                  * process exited, too, but it is our main process. */
2194
2195                 /* For D-Bus services we know the main pid right away,
2196                  * but wait for the bus name to appear on the
2197                  * bus. Notify services are similar. */
2198
2199                 service_set_main_pid(s, pid);
2200                 service_set_state(s, SERVICE_START);
2201         } else
2202                 assert_not_reached("Unknown service type");
2203
2204         return;
2205
2206 fail:
2207         log_warning("%s failed to run 'start' task: %s", UNIT(s)->id, strerror(-r));
2208         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2209 }
2210
2211 static void service_enter_start_pre(Service *s) {
2212         int r;
2213
2214         assert(s);
2215
2216         service_unwatch_control_pid(s);
2217
2218         if ((s->control_command = s->exec_command[SERVICE_EXEC_START_PRE])) {
2219
2220                 /* Before we start anything, let's clear up what might
2221                  * be left from previous runs. */
2222                 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2223
2224                 s->control_command_id = SERVICE_EXEC_START_PRE;
2225
2226                 r = service_spawn(s,
2227                                   s->control_command,
2228                                   true,
2229                                   false,
2230                                   !s->permissions_start_only,
2231                                   !s->root_directory_start_only,
2232                                   true,
2233                                   false,
2234                                   true,
2235                                   &s->control_pid);
2236                 if (r < 0)
2237                         goto fail;
2238
2239                 service_set_state(s, SERVICE_START_PRE);
2240         } else
2241                 service_enter_start(s);
2242
2243         return;
2244
2245 fail:
2246         log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
2247         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2248 }
2249
2250 static void service_enter_restart(Service *s) {
2251         int r;
2252         DBusError error;
2253
2254         assert(s);
2255         dbus_error_init(&error);
2256
2257         if (UNIT(s)->job) {
2258                 log_info("Job pending for unit, delaying automatic restart.");
2259
2260                 if ((r = unit_watch_timer(UNIT(s), s->restart_usec, &s->timer_watch)) < 0)
2261                         goto fail;
2262
2263                 return;
2264         }
2265
2266         /* Any units that are bound to this service must also be
2267          * restarted. We use JOB_RESTART (instead of the more obvious
2268          * JOB_START) here so that those dependency jobs will be added
2269          * as well. */
2270         r = manager_add_job(UNIT(s)->manager, JOB_RESTART, UNIT(s), JOB_FAIL, false, &error, NULL);
2271         if (r < 0)
2272                 goto fail;
2273
2274         log_debug("%s scheduled restart job.", UNIT(s)->id);
2275         return;
2276
2277 fail:
2278         log_warning("%s failed to schedule restart job: %s", UNIT(s)->id, bus_error(&error, -r));
2279         service_enter_dead(s, SERVICE_FAILURE_RESOURCES, false);
2280
2281         dbus_error_free(&error);
2282 }
2283
2284 static void service_enter_reload(Service *s) {
2285         int r;
2286
2287         assert(s);
2288
2289         service_unwatch_control_pid(s);
2290
2291         if ((s->control_command = s->exec_command[SERVICE_EXEC_RELOAD])) {
2292                 s->control_command_id = SERVICE_EXEC_RELOAD;
2293
2294                 r = service_spawn(s,
2295                                   s->control_command,
2296                                   true,
2297                                   false,
2298                                   !s->permissions_start_only,
2299                                   !s->root_directory_start_only,
2300                                   false,
2301                                   false,
2302                                   true,
2303                                   &s->control_pid);
2304                 if (r < 0)
2305                         goto fail;
2306
2307                 service_set_state(s, SERVICE_RELOAD);
2308         } else
2309                 service_enter_running(s, SERVICE_SUCCESS);
2310
2311         return;
2312
2313 fail:
2314         log_warning("%s failed to run 'reload' task: %s", UNIT(s)->id, strerror(-r));
2315         s->reload_result = SERVICE_FAILURE_RESOURCES;
2316         service_enter_running(s, SERVICE_SUCCESS);
2317 }
2318
2319 static void service_run_next_control(Service *s) {
2320         int r;
2321
2322         assert(s);
2323         assert(s->control_command);
2324         assert(s->control_command->command_next);
2325
2326         assert(s->control_command_id != SERVICE_EXEC_START);
2327
2328         s->control_command = s->control_command->command_next;
2329         service_unwatch_control_pid(s);
2330
2331         r = service_spawn(s,
2332                           s->control_command,
2333                           true,
2334                           false,
2335                           !s->permissions_start_only,
2336                           !s->root_directory_start_only,
2337                           s->control_command_id == SERVICE_EXEC_START_PRE ||
2338                           s->control_command_id == SERVICE_EXEC_STOP_POST,
2339                           false,
2340                           true,
2341                           &s->control_pid);
2342         if (r < 0)
2343                 goto fail;
2344
2345         return;
2346
2347 fail:
2348         log_warning("%s failed to run next control task: %s", UNIT(s)->id, strerror(-r));
2349
2350         if (s->state == SERVICE_START_PRE)
2351                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
2352         else if (s->state == SERVICE_STOP)
2353                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2354         else if (s->state == SERVICE_STOP_POST)
2355                 service_enter_dead(s, SERVICE_FAILURE_RESOURCES, true);
2356         else if (s->state == SERVICE_RELOAD) {
2357                 s->reload_result = SERVICE_FAILURE_RESOURCES;
2358                 service_enter_running(s, SERVICE_SUCCESS);
2359         } else
2360                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2361 }
2362
2363 static void service_run_next_main(Service *s) {
2364         pid_t pid;
2365         int r;
2366
2367         assert(s);
2368         assert(s->main_command);
2369         assert(s->main_command->command_next);
2370         assert(s->type == SERVICE_ONESHOT);
2371
2372         s->main_command = s->main_command->command_next;
2373         service_unwatch_main_pid(s);
2374
2375         r = service_spawn(s,
2376                           s->main_command,
2377                           true,
2378                           true,
2379                           true,
2380                           true,
2381                           true,
2382                           s->notify_access != NOTIFY_NONE,
2383                           false,
2384                           &pid);
2385         if (r < 0)
2386                 goto fail;
2387
2388         service_set_main_pid(s, pid);
2389
2390         return;
2391
2392 fail:
2393         log_warning("%s failed to run next main task: %s", UNIT(s)->id, strerror(-r));
2394         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
2395 }
2396
2397 static int service_start_limit_test(Service *s) {
2398         assert(s);
2399
2400         if (ratelimit_test(&s->start_limit))
2401                 return 0;
2402
2403         switch (s->start_limit_action) {
2404
2405         case SERVICE_START_LIMIT_NONE:
2406                 log_warning("%s start request repeated too quickly, refusing to start.", UNIT(s)->id);
2407                 break;
2408
2409         case SERVICE_START_LIMIT_REBOOT: {
2410                 DBusError error;
2411                 int r;
2412
2413                 dbus_error_init(&error);
2414
2415                 log_warning("%s start request repeated too quickly, rebooting.", UNIT(s)->id);
2416
2417                 r = manager_add_job_by_name(UNIT(s)->manager, JOB_START, SPECIAL_REBOOT_TARGET, JOB_REPLACE, true, &error, NULL);
2418                 if (r < 0) {
2419                         log_error("Failed to reboot: %s.", bus_error(&error, r));
2420                         dbus_error_free(&error);
2421                 }
2422
2423                 break;
2424         }
2425
2426         case SERVICE_START_LIMIT_REBOOT_FORCE:
2427                 log_warning("%s start request repeated too quickly, forcibly rebooting.", UNIT(s)->id);
2428                 UNIT(s)->manager->exit_code = MANAGER_REBOOT;
2429                 break;
2430
2431         case SERVICE_START_LIMIT_REBOOT_IMMEDIATE:
2432                 log_warning("%s start request repeated too quickly, rebooting immediately.", UNIT(s)->id);
2433                 reboot(RB_AUTOBOOT);
2434                 break;
2435
2436         default:
2437                 log_error("start limit action=%i", s->start_limit_action);
2438                 assert_not_reached("Unknown StartLimitAction.");
2439         }
2440
2441         return -ECANCELED;
2442 }
2443
2444 static int service_start(Unit *u) {
2445         Service *s = SERVICE(u);
2446         int r;
2447
2448         assert(s);
2449
2450         /* We cannot fulfill this request right now, try again later
2451          * please! */
2452         if (s->state == SERVICE_STOP ||
2453             s->state == SERVICE_STOP_SIGTERM ||
2454             s->state == SERVICE_STOP_SIGKILL ||
2455             s->state == SERVICE_STOP_POST ||
2456             s->state == SERVICE_FINAL_SIGTERM ||
2457             s->state == SERVICE_FINAL_SIGKILL)
2458                 return -EAGAIN;
2459
2460         /* Already on it! */
2461         if (s->state == SERVICE_START_PRE ||
2462             s->state == SERVICE_START ||
2463             s->state == SERVICE_START_POST)
2464                 return 0;
2465
2466         /* A service that will be restarted must be stopped first to
2467          * trigger BindTo and/or OnFailure dependencies. If a user
2468          * does not want to wait for the holdoff time to elapse, the
2469          * service should be manually restarted, not started. */
2470         if (s->state == SERVICE_AUTO_RESTART) {
2471                 log_warning("%s automatic restart is pending, must be stopped before issuing start request.", UNIT(s)->id);
2472                 return -ECANCELED;
2473         }
2474
2475         assert(s->state == SERVICE_DEAD || s->state == SERVICE_FAILED);
2476
2477         /* Make sure we don't enter a busy loop of some kind. */
2478         r = service_start_limit_test(s);
2479         if (r < 0) {
2480                 service_notify_sockets_dead(s, true);
2481                 return r;
2482         }
2483
2484         s->result = SERVICE_SUCCESS;
2485         s->reload_result = SERVICE_SUCCESS;
2486         s->main_pid_known = false;
2487         s->main_pid_alien = false;
2488         s->forbid_restart = false;
2489
2490         service_enter_start_pre(s);
2491         return 0;
2492 }
2493
2494 static int service_stop(Unit *u) {
2495         Service *s = SERVICE(u);
2496
2497         assert(s);
2498
2499         /* Don't create restart jobs from here. */
2500         s->forbid_restart = true;
2501
2502         /* Already on it */
2503         if (s->state == SERVICE_STOP ||
2504             s->state == SERVICE_STOP_SIGTERM ||
2505             s->state == SERVICE_STOP_SIGKILL ||
2506             s->state == SERVICE_STOP_POST ||
2507             s->state == SERVICE_FINAL_SIGTERM ||
2508             s->state == SERVICE_FINAL_SIGKILL)
2509                 return 0;
2510
2511         /* A restart will be scheduled or is in progress. */
2512         if (s->state == SERVICE_AUTO_RESTART) {
2513                 service_set_state(s, SERVICE_DEAD);
2514                 return 0;
2515         }
2516
2517         /* If there's already something running we go directly into
2518          * kill mode. */
2519         if (s->state == SERVICE_START_PRE ||
2520             s->state == SERVICE_START ||
2521             s->state == SERVICE_START_POST ||
2522             s->state == SERVICE_RELOAD) {
2523                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_SUCCESS);
2524                 return 0;
2525         }
2526
2527         assert(s->state == SERVICE_RUNNING ||
2528                s->state == SERVICE_EXITED);
2529
2530         service_enter_stop(s, SERVICE_SUCCESS);
2531         return 0;
2532 }
2533
2534 static int service_reload(Unit *u) {
2535         Service *s = SERVICE(u);
2536
2537         assert(s);
2538
2539         assert(s->state == SERVICE_RUNNING || s->state == SERVICE_EXITED);
2540
2541         service_enter_reload(s);
2542         return 0;
2543 }
2544
2545 static bool service_can_reload(Unit *u) {
2546         Service *s = SERVICE(u);
2547
2548         assert(s);
2549
2550         return !!s->exec_command[SERVICE_EXEC_RELOAD];
2551 }
2552
2553 static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
2554         Service *s = SERVICE(u);
2555
2556         assert(u);
2557         assert(f);
2558         assert(fds);
2559
2560         unit_serialize_item(u, f, "state", service_state_to_string(s->state));
2561         unit_serialize_item(u, f, "result", service_result_to_string(s->result));
2562         unit_serialize_item(u, f, "reload-result", service_result_to_string(s->reload_result));
2563
2564         if (s->control_pid > 0)
2565                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
2566
2567         if (s->main_pid_known && s->main_pid > 0)
2568                 unit_serialize_item_format(u, f, "main-pid", "%lu", (unsigned long) s->main_pid);
2569
2570         unit_serialize_item(u, f, "main-pid-known", yes_no(s->main_pid_known));
2571
2572         if (s->status_text)
2573                 unit_serialize_item(u, f, "status-text", s->status_text);
2574
2575         /* FIXME: There's a minor uncleanliness here: if there are
2576          * multiple commands attached here, we will start from the
2577          * first one again */
2578         if (s->control_command_id >= 0)
2579                 unit_serialize_item(u, f, "control-command", service_exec_command_to_string(s->control_command_id));
2580
2581         if (s->socket_fd >= 0) {
2582                 int copy;
2583
2584                 if ((copy = fdset_put_dup(fds, s->socket_fd)) < 0)
2585                         return copy;
2586
2587                 unit_serialize_item_format(u, f, "socket-fd", "%i", copy);
2588         }
2589
2590         if (s->main_exec_status.pid > 0) {
2591                 unit_serialize_item_format(u, f, "main-exec-status-pid", "%lu", (unsigned long) s->main_exec_status.pid);
2592                 dual_timestamp_serialize(f, "main-exec-status-start", &s->main_exec_status.start_timestamp);
2593                 dual_timestamp_serialize(f, "main-exec-status-exit", &s->main_exec_status.exit_timestamp);
2594
2595                 if (dual_timestamp_is_set(&s->main_exec_status.exit_timestamp)) {
2596                         unit_serialize_item_format(u, f, "main-exec-status-code", "%i", s->main_exec_status.code);
2597                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
2598                 }
2599         }
2600         if (dual_timestamp_is_set(&s->watchdog_timestamp))
2601                 dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
2602
2603         return 0;
2604 }
2605
2606 static int service_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2607         Service *s = SERVICE(u);
2608
2609         assert(u);
2610         assert(key);
2611         assert(value);
2612         assert(fds);
2613
2614         if (streq(key, "state")) {
2615                 ServiceState state;
2616
2617                 if ((state = service_state_from_string(value)) < 0)
2618                         log_debug("Failed to parse state value %s", value);
2619                 else
2620                         s->deserialized_state = state;
2621         } else if (streq(key, "result")) {
2622                 ServiceResult f;
2623
2624                 f = service_result_from_string(value);
2625                 if (f < 0)
2626                         log_debug("Failed to parse result value %s", value);
2627                 else if (f != SERVICE_SUCCESS)
2628                         s->result = f;
2629
2630         } else if (streq(key, "reload-result")) {
2631                 ServiceResult f;
2632
2633                 f = service_result_from_string(value);
2634                 if (f < 0)
2635                         log_debug("Failed to parse reload result value %s", value);
2636                 else if (f != SERVICE_SUCCESS)
2637                         s->reload_result = f;
2638
2639         } else if (streq(key, "control-pid")) {
2640                 pid_t pid;
2641
2642                 if (parse_pid(value, &pid) < 0)
2643                         log_debug("Failed to parse control-pid value %s", value);
2644                 else
2645                         s->control_pid = pid;
2646         } else if (streq(key, "main-pid")) {
2647                 pid_t pid;
2648
2649                 if (parse_pid(value, &pid) < 0)
2650                         log_debug("Failed to parse main-pid value %s", value);
2651                 else
2652                         service_set_main_pid(s, (pid_t) pid);
2653         } else if (streq(key, "main-pid-known")) {
2654                 int b;
2655
2656                 if ((b = parse_boolean(value)) < 0)
2657                         log_debug("Failed to parse main-pid-known value %s", value);
2658                 else
2659                         s->main_pid_known = b;
2660         } else if (streq(key, "status-text")) {
2661                 char *t;
2662
2663                 if ((t = strdup(value))) {
2664                         free(s->status_text);
2665                         s->status_text = t;
2666                 }
2667
2668         } else if (streq(key, "control-command")) {
2669                 ServiceExecCommand id;
2670
2671                 if ((id = service_exec_command_from_string(value)) < 0)
2672                         log_debug("Failed to parse exec-command value %s", value);
2673                 else {
2674                         s->control_command_id = id;
2675                         s->control_command = s->exec_command[id];
2676                 }
2677         } else if (streq(key, "socket-fd")) {
2678                 int fd;
2679
2680                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2681                         log_debug("Failed to parse socket-fd value %s", value);
2682                 else {
2683
2684                         if (s->socket_fd >= 0)
2685                                 close_nointr_nofail(s->socket_fd);
2686                         s->socket_fd = fdset_remove(fds, fd);
2687                 }
2688         } else if (streq(key, "main-exec-status-pid")) {
2689                 pid_t pid;
2690
2691                 if (parse_pid(value, &pid) < 0)
2692                         log_debug("Failed to parse main-exec-status-pid value %s", value);
2693                 else
2694                         s->main_exec_status.pid = pid;
2695         } else if (streq(key, "main-exec-status-code")) {
2696                 int i;
2697
2698                 if (safe_atoi(value, &i) < 0)
2699                         log_debug("Failed to parse main-exec-status-code value %s", value);
2700                 else
2701                         s->main_exec_status.code = i;
2702         } else if (streq(key, "main-exec-status-status")) {
2703                 int i;
2704
2705                 if (safe_atoi(value, &i) < 0)
2706                         log_debug("Failed to parse main-exec-status-status value %s", value);
2707                 else
2708                         s->main_exec_status.status = i;
2709         } else if (streq(key, "main-exec-status-start"))
2710                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
2711         else if (streq(key, "main-exec-status-exit"))
2712                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
2713         else if (streq(key, "watchdog-timestamp"))
2714                 dual_timestamp_deserialize(value, &s->watchdog_timestamp);
2715         else
2716                 log_debug("Unknown serialization key '%s'", key);
2717
2718         return 0;
2719 }
2720
2721 static UnitActiveState service_active_state(Unit *u) {
2722         const UnitActiveState *table;
2723
2724         assert(u);
2725
2726         table = SERVICE(u)->type == SERVICE_IDLE ? state_translation_table_idle : state_translation_table;
2727
2728         return table[SERVICE(u)->state];
2729 }
2730
2731 static const char *service_sub_state_to_string(Unit *u) {
2732         assert(u);
2733
2734         return service_state_to_string(SERVICE(u)->state);
2735 }
2736
2737 static bool service_check_gc(Unit *u) {
2738         Service *s = SERVICE(u);
2739
2740         assert(s);
2741
2742         /* Never clean up services that still have a process around,
2743          * even if the service is formally dead. */
2744         if (cgroup_good(s) > 0 ||
2745             main_pid_good(s) > 0 ||
2746             control_pid_good(s) > 0)
2747                 return true;
2748
2749 #ifdef HAVE_SYSV_COMPAT
2750         if (s->is_sysv)
2751                 return true;
2752 #endif
2753
2754         return false;
2755 }
2756
2757 static bool service_check_snapshot(Unit *u) {
2758         Service *s = SERVICE(u);
2759
2760         assert(s);
2761
2762         return !s->got_socket_fd;
2763 }
2764
2765 static int service_retry_pid_file(Service *s) {
2766         int r;
2767
2768         assert(s->pid_file);
2769         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2770
2771         r = service_load_pid_file(s, false);
2772         if (r < 0)
2773                 return r;
2774
2775         service_unwatch_pid_file(s);
2776
2777         service_enter_running(s, SERVICE_SUCCESS);
2778         return 0;
2779 }
2780
2781 static int service_watch_pid_file(Service *s) {
2782         int r;
2783
2784         log_debug("Setting watch for %s's PID file %s", UNIT(s)->id, s->pid_file_pathspec->path);
2785         r = path_spec_watch(s->pid_file_pathspec, UNIT(s));
2786         if (r < 0)
2787                 goto fail;
2788
2789         /* the pidfile might have appeared just before we set the watch */
2790         service_retry_pid_file(s);
2791
2792         return 0;
2793 fail:
2794         log_error("Failed to set a watch for %s's PID file %s: %s",
2795                   UNIT(s)->id, s->pid_file_pathspec->path, strerror(-r));
2796         service_unwatch_pid_file(s);
2797         return r;
2798 }
2799
2800 static int service_demand_pid_file(Service *s) {
2801         PathSpec *ps;
2802
2803         assert(s->pid_file);
2804         assert(!s->pid_file_pathspec);
2805
2806         ps = new0(PathSpec, 1);
2807         if (!ps)
2808                 return -ENOMEM;
2809
2810         ps->path = strdup(s->pid_file);
2811         if (!ps->path) {
2812                 free(ps);
2813                 return -ENOMEM;
2814         }
2815
2816         path_kill_slashes(ps->path);
2817
2818         /* PATH_CHANGED would not be enough. There are daemons (sendmail) that
2819          * keep their PID file open all the time. */
2820         ps->type = PATH_MODIFIED;
2821         ps->inotify_fd = -1;
2822
2823         s->pid_file_pathspec = ps;
2824
2825         return service_watch_pid_file(s);
2826 }
2827
2828 static void service_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2829         Service *s = SERVICE(u);
2830
2831         assert(s);
2832         assert(fd >= 0);
2833         assert(s->state == SERVICE_START || s->state == SERVICE_START_POST);
2834         assert(s->pid_file_pathspec);
2835         assert(path_spec_owns_inotify_fd(s->pid_file_pathspec, fd));
2836
2837         log_debug("inotify event for %s", u->id);
2838
2839         if (path_spec_fd_event(s->pid_file_pathspec, events) < 0)
2840                 goto fail;
2841
2842         if (service_retry_pid_file(s) == 0)
2843                 return;
2844
2845         if (service_watch_pid_file(s) < 0)
2846                 goto fail;
2847
2848         return;
2849 fail:
2850         service_unwatch_pid_file(s);
2851         service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_RESOURCES);
2852 }
2853
2854 static void service_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2855         Service *s = SERVICE(u);
2856         ServiceResult f;
2857
2858         assert(s);
2859         assert(pid >= 0);
2860
2861         if (UNIT(s)->fragment_path ? is_clean_exit(code, status) : is_clean_exit_lsb(code, status))
2862                 f = SERVICE_SUCCESS;
2863         else if (code == CLD_EXITED)
2864                 f = SERVICE_FAILURE_EXIT_CODE;
2865         else if (code == CLD_KILLED)
2866                 f = SERVICE_FAILURE_SIGNAL;
2867         else if (code == CLD_DUMPED)
2868                 f = SERVICE_FAILURE_CORE_DUMP;
2869         else
2870                 assert_not_reached("Unknown code");
2871
2872         if (s->main_pid == pid) {
2873                 /* Forking services may occasionally move to a new PID.
2874                  * As long as they update the PID file before exiting the old
2875                  * PID, they're fine. */
2876                 if (service_load_pid_file(s, false) == 0)
2877                         return;
2878
2879                 s->main_pid = 0;
2880                 exec_status_exit(&s->main_exec_status, &s->exec_context, pid, code, status);
2881
2882                 /* If this is not a forking service than the main
2883                  * process got started and hence we copy the exit
2884                  * status so that it is recorded both as main and as
2885                  * control process exit status */
2886                 if (s->main_command) {
2887                         s->main_command->exec_status = s->main_exec_status;
2888
2889                         if (s->main_command->ignore)
2890                                 f = SERVICE_SUCCESS;
2891                 }
2892
2893                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2894                          "%s: main process exited, code=%s, status=%i", u->id, sigchld_code_to_string(code), status);
2895
2896                 if (f != SERVICE_SUCCESS)
2897                         s->result = f;
2898
2899                 if (s->main_command &&
2900                     s->main_command->command_next &&
2901                     f == SERVICE_SUCCESS) {
2902
2903                         /* There is another command to *
2904                          * execute, so let's do that. */
2905
2906                         log_debug("%s running next main command for state %s", u->id, service_state_to_string(s->state));
2907                         service_run_next_main(s);
2908
2909                 } else {
2910
2911                         /* The service exited, so the service is officially
2912                          * gone. */
2913                         s->main_command = NULL;
2914
2915                         switch (s->state) {
2916
2917                         case SERVICE_START_POST:
2918                         case SERVICE_RELOAD:
2919                         case SERVICE_STOP:
2920                                 /* Need to wait until the operation is
2921                                  * done */
2922                                 break;
2923
2924                         case SERVICE_START:
2925                                 if (s->type == SERVICE_ONESHOT) {
2926                                         /* This was our main goal, so let's go on */
2927                                         if (f == SERVICE_SUCCESS)
2928                                                 service_enter_start_post(s);
2929                                         else
2930                                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
2931                                         break;
2932                                 } else {
2933                                         assert(s->type == SERVICE_DBUS || s->type == SERVICE_NOTIFY);
2934
2935                                         /* Fall through */
2936                                 }
2937
2938                         case SERVICE_RUNNING:
2939                                 service_enter_running(s, f);
2940                                 break;
2941
2942                         case SERVICE_STOP_SIGTERM:
2943                         case SERVICE_STOP_SIGKILL:
2944
2945                                 if (!control_pid_good(s))
2946                                         service_enter_stop_post(s, f);
2947
2948                                 /* If there is still a control process, wait for that first */
2949                                 break;
2950
2951                         default:
2952                                 assert_not_reached("Uh, main process died at wrong time.");
2953                         }
2954                 }
2955
2956         } else if (s->control_pid == pid) {
2957
2958                 s->control_pid = 0;
2959
2960                 if (s->control_command) {
2961                         exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2962
2963                         if (s->control_command->ignore)
2964                                 f = SERVICE_SUCCESS;
2965                 }
2966
2967                 log_full(f == SERVICE_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2968                          "%s: control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
2969
2970                 if (f != SERVICE_SUCCESS)
2971                         s->result = f;
2972
2973                 /* Immediately get rid of the cgroup, so that the
2974                  * kernel doesn't delay the cgroup empty messages for
2975                  * the service cgroup any longer than necessary */
2976                 cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, SIGKILL, true, true, NULL, "control");
2977
2978                 if (s->control_command &&
2979                     s->control_command->command_next &&
2980                     f == SERVICE_SUCCESS) {
2981
2982                         /* There is another command to *
2983                          * execute, so let's do that. */
2984
2985                         log_debug("%s running next control command for state %s", u->id, service_state_to_string(s->state));
2986                         service_run_next_control(s);
2987
2988                 } else {
2989                         /* No further commands for this step, so let's
2990                          * figure out what to do next */
2991
2992                         s->control_command = NULL;
2993                         s->control_command_id = _SERVICE_EXEC_COMMAND_INVALID;
2994
2995                         log_debug("%s got final SIGCHLD for state %s", u->id, service_state_to_string(s->state));
2996
2997                         switch (s->state) {
2998
2999                         case SERVICE_START_PRE:
3000                                 if (f == SERVICE_SUCCESS)
3001                                         service_enter_start(s);
3002                                 else
3003                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3004                                 break;
3005
3006                         case SERVICE_START:
3007                                 assert(s->type == SERVICE_FORKING);
3008
3009                                 if (f != SERVICE_SUCCESS) {
3010                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, f);
3011                                         break;
3012                                 }
3013
3014                                 if (s->pid_file) {
3015                                         bool has_start_post;
3016                                         int r;
3017
3018                                         /* Let's try to load the pid file here if we can.
3019                                          * The PID file might actually be created by a START_POST
3020                                          * script. In that case don't worry if the loading fails. */
3021
3022                                         has_start_post = !!s->exec_command[SERVICE_EXEC_START_POST];
3023                                         r = service_load_pid_file(s, !has_start_post);
3024                                         if (!has_start_post && r < 0) {
3025                                                 r = service_demand_pid_file(s);
3026                                                 if (r < 0 || !cgroup_good(s))
3027                                                         service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3028                                                 break;
3029                                         }
3030                                 } else
3031                                         service_search_main_pid(s);
3032
3033                                 service_enter_start_post(s);
3034                                 break;
3035
3036                         case SERVICE_START_POST:
3037                                 if (f != SERVICE_SUCCESS) {
3038                                         service_enter_stop(s, f);
3039                                         break;
3040                                 }
3041
3042                                 if (s->pid_file) {
3043                                         int r;
3044
3045                                         r = service_load_pid_file(s, true);
3046                                         if (r < 0) {
3047                                                 r = service_demand_pid_file(s);
3048                                                 if (r < 0 || !cgroup_good(s))
3049                                                         service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3050                                                 break;
3051                                         }
3052                                 } else
3053                                         service_search_main_pid(s);
3054
3055                                 service_enter_running(s, SERVICE_SUCCESS);
3056                                 break;
3057
3058                         case SERVICE_RELOAD:
3059                                 if (f == SERVICE_SUCCESS) {
3060                                         service_load_pid_file(s, true);
3061                                         service_search_main_pid(s);
3062                                 }
3063
3064                                 s->reload_result = f;
3065                                 service_enter_running(s, SERVICE_SUCCESS);
3066                                 break;
3067
3068                         case SERVICE_STOP:
3069                                 service_enter_signal(s, SERVICE_STOP_SIGTERM, f);
3070                                 break;
3071
3072                         case SERVICE_STOP_SIGTERM:
3073                         case SERVICE_STOP_SIGKILL:
3074                                 if (main_pid_good(s) <= 0)
3075                                         service_enter_stop_post(s, f);
3076
3077                                 /* If there is still a service
3078                                  * process around, wait until
3079                                  * that one quit, too */
3080                                 break;
3081
3082                         case SERVICE_STOP_POST:
3083                         case SERVICE_FINAL_SIGTERM:
3084                         case SERVICE_FINAL_SIGKILL:
3085                                 service_enter_dead(s, f, true);
3086                                 break;
3087
3088                         default:
3089                                 assert_not_reached("Uh, control process died at wrong time.");
3090                         }
3091                 }
3092         }
3093
3094         /* Notify clients about changed exit status */
3095         unit_add_to_dbus_queue(u);
3096 }
3097
3098 static void service_timer_event(Unit *u, uint64_t elapsed, Watch* w) {
3099         Service *s = SERVICE(u);
3100
3101         assert(s);
3102         assert(elapsed == 1);
3103
3104         if (w == &s->watchdog_watch) {
3105                 service_handle_watchdog(s);
3106                 return;
3107         }
3108
3109         assert(w == &s->timer_watch);
3110
3111         switch (s->state) {
3112
3113         case SERVICE_START_PRE:
3114         case SERVICE_START:
3115                 log_warning("%s operation timed out. Terminating.", u->id);
3116                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3117                 break;
3118
3119         case SERVICE_START_POST:
3120                 log_warning("%s operation timed out. Stopping.", u->id);
3121                 service_enter_stop(s, SERVICE_FAILURE_TIMEOUT);
3122                 break;
3123
3124         case SERVICE_RELOAD:
3125                 log_warning("%s operation timed out. Stopping.", u->id);
3126                 s->reload_result = SERVICE_FAILURE_TIMEOUT;
3127                 service_enter_running(s, SERVICE_SUCCESS);
3128                 break;
3129
3130         case SERVICE_STOP:
3131                 log_warning("%s stopping timed out. Terminating.", u->id);
3132                 service_enter_signal(s, SERVICE_STOP_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3133                 break;
3134
3135         case SERVICE_STOP_SIGTERM:
3136                 if (s->exec_context.send_sigkill) {
3137                         log_warning("%s stopping timed out. Killing.", u->id);
3138                         service_enter_signal(s, SERVICE_STOP_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3139                 } else {
3140                         log_warning("%s stopping timed out. Skipping SIGKILL.", u->id);
3141                         service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3142                 }
3143
3144                 break;
3145
3146         case SERVICE_STOP_SIGKILL:
3147                 /* Uh, we sent a SIGKILL and it is still not gone?
3148                  * Must be something we cannot kill, so let's just be
3149                  * weirded out and continue */
3150
3151                 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
3152                 service_enter_stop_post(s, SERVICE_FAILURE_TIMEOUT);
3153                 break;
3154
3155         case SERVICE_STOP_POST:
3156                 log_warning("%s stopping timed out (2). Terminating.", u->id);
3157                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_TIMEOUT);
3158                 break;
3159
3160         case SERVICE_FINAL_SIGTERM:
3161                 if (s->exec_context.send_sigkill) {
3162                         log_warning("%s stopping timed out (2). Killing.", u->id);
3163                         service_enter_signal(s, SERVICE_FINAL_SIGKILL, SERVICE_FAILURE_TIMEOUT);
3164                 } else {
3165                         log_warning("%s stopping timed out (2). Skipping SIGKILL. Entering failed mode.", u->id);
3166                         service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, false);
3167                 }
3168
3169                 break;
3170
3171         case SERVICE_FINAL_SIGKILL:
3172                 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
3173                 service_enter_dead(s, SERVICE_FAILURE_TIMEOUT, true);
3174                 break;
3175
3176         case SERVICE_AUTO_RESTART:
3177                 log_info("%s holdoff time over, scheduling restart.", u->id);
3178                 service_enter_restart(s);
3179                 break;
3180
3181         default:
3182                 assert_not_reached("Timeout at wrong time.");
3183         }
3184 }
3185
3186 static void service_cgroup_notify_event(Unit *u) {
3187         Service *s = SERVICE(u);
3188
3189         assert(u);
3190
3191         log_debug("%s: cgroup is empty", u->id);
3192
3193         switch (s->state) {
3194
3195                 /* Waiting for SIGCHLD is usually more interesting,
3196                  * because it includes return codes/signals. Which is
3197                  * why we ignore the cgroup events for most cases,
3198                  * except when we don't know pid which to expect the
3199                  * SIGCHLD for. */
3200
3201         case SERVICE_START:
3202         case SERVICE_START_POST:
3203                 /* If we were hoping for the daemon to write its PID file,
3204                  * we can give up now. */
3205                 if (s->pid_file_pathspec) {
3206                         log_warning("%s never wrote its PID file. Failing.", UNIT(s)->id);
3207                         service_unwatch_pid_file(s);
3208                         if (s->state == SERVICE_START)
3209                                 service_enter_signal(s, SERVICE_FINAL_SIGTERM, SERVICE_FAILURE_RESOURCES);
3210                         else
3211                                 service_enter_stop(s, SERVICE_FAILURE_RESOURCES);
3212                 }
3213                 break;
3214
3215         case SERVICE_RUNNING:
3216                 /* service_enter_running() will figure out what to do */
3217                 service_enter_running(s, SERVICE_SUCCESS);
3218                 break;
3219
3220         case SERVICE_STOP_SIGTERM:
3221         case SERVICE_STOP_SIGKILL:
3222
3223                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3224                         service_enter_stop_post(s, SERVICE_SUCCESS);
3225
3226                 break;
3227
3228         case SERVICE_FINAL_SIGTERM:
3229         case SERVICE_FINAL_SIGKILL:
3230                 if (main_pid_good(s) <= 0 && !control_pid_good(s))
3231                         service_enter_dead(s, SERVICE_SUCCESS, true);
3232
3233                 break;
3234
3235         default:
3236                 ;
3237         }
3238 }
3239
3240 static void service_notify_message(Unit *u, pid_t pid, char **tags) {
3241         Service *s = SERVICE(u);
3242         const char *e;
3243
3244         assert(u);
3245
3246         if (s->notify_access == NOTIFY_NONE) {
3247                 log_warning("%s: Got notification message from PID %lu, but reception is disabled.",
3248                             u->id, (unsigned long) pid);
3249                 return;
3250         }
3251
3252         if (s->notify_access == NOTIFY_MAIN && pid != s->main_pid) {
3253                 log_warning("%s: Got notification message from PID %lu, but reception only permitted for PID %lu",
3254                             u->id, (unsigned long) pid, (unsigned long) s->main_pid);
3255                 return;
3256         }
3257
3258         log_debug("%s: Got message", u->id);
3259
3260         /* Interpret MAINPID= */
3261         if ((e = strv_find_prefix(tags, "MAINPID=")) &&
3262             (s->state == SERVICE_START ||
3263              s->state == SERVICE_START_POST ||
3264              s->state == SERVICE_RUNNING ||
3265              s->state == SERVICE_RELOAD)) {
3266
3267                 if (parse_pid(e + 8, &pid) < 0)
3268                         log_warning("Failed to parse notification message %s", e);
3269                 else {
3270                         log_debug("%s: got %s", u->id, e);
3271                         service_set_main_pid(s, pid);
3272                 }
3273         }
3274
3275         /* Interpret READY= */
3276         if (s->type == SERVICE_NOTIFY &&
3277             s->state == SERVICE_START &&
3278             strv_find(tags, "READY=1")) {
3279                 log_debug("%s: got READY=1", u->id);
3280
3281                 service_enter_start_post(s);
3282         }
3283
3284         /* Interpret STATUS= */
3285         e = strv_find_prefix(tags, "STATUS=");
3286         if (e) {
3287                 char *t;
3288
3289                 if (e[7]) {
3290
3291                         if (!utf8_is_valid(e+7)) {
3292                                 log_warning("Status message in notification is not UTF-8 clean.");
3293                                 return;
3294                         }
3295
3296                         t = strdup(e+7);
3297                         if (!t) {
3298                                 log_error("Failed to allocate string.");
3299                                 return;
3300                         }
3301
3302                         log_debug("%s: got %s", u->id, e);
3303
3304                         free(s->status_text);
3305                         s->status_text = t;
3306                 } else {
3307                         free(s->status_text);
3308                         s->status_text = NULL;
3309                 }
3310
3311         }
3312         if (strv_find(tags, "WATCHDOG=1")) {
3313                 log_debug("%s: got WATCHDOG=1", u->id);
3314                 service_reset_watchdog(s);
3315         }
3316
3317         /* Notify clients about changed status or main pid */
3318         unit_add_to_dbus_queue(u);
3319 }
3320
3321 #ifdef HAVE_SYSV_COMPAT
3322
3323 #ifdef TARGET_SUSE
3324 static void sysv_facility_in_insserv_conf(Manager *mgr) {
3325         FILE *f=NULL;
3326         int r;
3327
3328         if (!(f = fopen("/etc/insserv.conf", "re"))) {
3329                 r = errno == ENOENT ? 0 : -errno;
3330                 goto finish;
3331         }
3332
3333         while (!feof(f)) {
3334                 char l[LINE_MAX], *t;
3335                 char **parsed = NULL;
3336
3337                 if (!fgets(l, sizeof(l), f)) {
3338                         if (feof(f))
3339                                 break;
3340
3341                         r = -errno;
3342                         log_error("Failed to read configuration file '/etc/insserv.conf': %s", strerror(-r));
3343                         goto finish;
3344                 }
3345
3346                 t = strstrip(l);
3347                 if (*t != '$' && *t != '<')
3348                         continue;
3349
3350                 parsed = strv_split(t,WHITESPACE);
3351                 /* we ignore <interactive>, not used, equivalent to X-Interactive */
3352                 if (parsed && !startswith_no_case (parsed[0], "<interactive>")) {
3353                         char *facility;
3354                         Unit *u;
3355                         if (sysv_translate_facility(parsed[0], NULL, &facility) < 0)
3356                                 continue;
3357                         if ((u = manager_get_unit(mgr, facility)) && (u->type == UNIT_TARGET)) {
3358                                 UnitDependency e;
3359                                 char *dep = NULL, *name, **j;
3360
3361                                 STRV_FOREACH (j, parsed+1) {
3362                                         if (*j[0]=='+') {
3363                                                 e = UNIT_WANTS;
3364                                                 name = *j+1;
3365                                         }
3366                                         else {
3367                                                 e = UNIT_REQUIRES;
3368                                                 name = *j;
3369                                         }
3370                                         if (sysv_translate_facility(name, NULL, &dep) < 0)
3371                                                 continue;
3372
3373                                         r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, e, dep, NULL, true);
3374                                         free(dep);
3375                                 }
3376                         }
3377                         free(facility);
3378                 }
3379                 strv_free(parsed);
3380         }
3381 finish:
3382         if (f)
3383                 fclose(f);
3384
3385 }
3386 #endif
3387
3388 static int service_enumerate(Manager *m) {
3389         char **p;
3390         unsigned i;
3391         DIR *d = NULL;
3392         char *path = NULL, *fpath = NULL, *name = NULL;
3393         Set *runlevel_services[ELEMENTSOF(rcnd_table)], *shutdown_services = NULL;
3394         Unit *service;
3395         Iterator j;
3396         int r;
3397
3398         assert(m);
3399
3400         if (m->running_as != MANAGER_SYSTEM)
3401                 return 0;
3402
3403         zero(runlevel_services);
3404
3405         STRV_FOREACH(p, m->lookup_paths.sysvrcnd_path)
3406                 for (i = 0; i < ELEMENTSOF(rcnd_table); i ++) {
3407                         struct dirent *de;
3408
3409                         free(path);
3410                         path = strjoin(*p, "/", rcnd_table[i].path, NULL);
3411                         if (!path) {
3412                                 r = -ENOMEM;
3413                                 goto finish;
3414                         }
3415
3416                         if (d)
3417                                 closedir(d);
3418
3419                         if (!(d = opendir(path))) {
3420                                 if (errno != ENOENT)
3421                                         log_warning("opendir() failed on %s: %s", path, strerror(errno));
3422
3423                                 continue;
3424                         }
3425
3426                         while ((de = readdir(d))) {
3427                                 int a, b;
3428
3429                                 if (ignore_file(de->d_name))
3430                                         continue;
3431
3432                                 if (de->d_name[0] != 'S' && de->d_name[0] != 'K')
3433                                         continue;
3434
3435                                 if (strlen(de->d_name) < 4)
3436                                         continue;
3437
3438                                 a = undecchar(de->d_name[1]);
3439                                 b = undecchar(de->d_name[2]);
3440
3441                                 if (a < 0 || b < 0)
3442                                         continue;
3443
3444                                 free(fpath);
3445                                 fpath = strjoin(path, "/", de->d_name, NULL);
3446                                 if (!fpath) {
3447                                         r = -ENOMEM;
3448                                         goto finish;
3449                                 }
3450
3451                                 if (access(fpath, X_OK) < 0) {
3452
3453                                         if (errno != ENOENT)
3454                                                 log_warning("access() failed on %s: %s", fpath, strerror(errno));
3455
3456                                         continue;
3457                                 }
3458
3459                                 free(name);
3460                                 if (!(name = sysv_translate_name(de->d_name + 3))) {
3461                                         r = -ENOMEM;
3462                                         goto finish;
3463                                 }
3464
3465                                 if ((r = manager_load_unit_prepare(m, name, NULL, NULL, &service)) < 0) {
3466                                         log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
3467                                         continue;
3468                                 }
3469
3470                                 if (de->d_name[0] == 'S')  {
3471
3472                                         if (rcnd_table[i].type == RUNLEVEL_UP || rcnd_table[i].type == RUNLEVEL_SYSINIT) {
3473                                                 SERVICE(service)->sysv_start_priority_from_rcnd =
3474                                                         MAX(a*10 + b, SERVICE(service)->sysv_start_priority_from_rcnd);
3475
3476                                                 SERVICE(service)->sysv_enabled = true;
3477                                         }
3478
3479                                         if ((r = set_ensure_allocated(&runlevel_services[i], trivial_hash_func, trivial_compare_func)) < 0)
3480                                                 goto finish;
3481
3482                                         if ((r = set_put(runlevel_services[i], service)) < 0)
3483                                                 goto finish;
3484
3485                                 } else if (de->d_name[0] == 'K' &&
3486                                            (rcnd_table[i].type == RUNLEVEL_DOWN ||
3487                                             rcnd_table[i].type == RUNLEVEL_SYSINIT)) {
3488
3489                                         if ((r = set_ensure_allocated(&shutdown_services, trivial_hash_func, trivial_compare_func)) < 0)
3490                                                 goto finish;
3491
3492                                         if ((r = set_put(shutdown_services, service)) < 0)
3493                                                 goto finish;
3494                                 }
3495                         }
3496                 }
3497
3498         /* Now we loaded all stubs and are aware of the lowest
3499         start-up priority for all services, not let's actually load
3500         the services, this will also tell us which services are
3501         actually native now */
3502         manager_dispatch_load_queue(m);
3503
3504         /* If this is a native service, rely on native ways to pull in
3505          * a service, don't pull it in via sysv rcN.d links. */
3506         for (i = 0; i < ELEMENTSOF(rcnd_table); i ++)
3507                 SET_FOREACH(service, runlevel_services[i], j) {
3508                         service = unit_follow_merge(service);
3509
3510                         if (service->fragment_path)
3511                                 continue;
3512
3513                         if ((r = unit_add_two_dependencies_by_name_inverse(service, UNIT_AFTER, UNIT_WANTS, rcnd_table[i].target, NULL, true)) < 0)
3514                                 goto finish;
3515                 }
3516
3517         /* We honour K links only for halt/reboot. For the normal
3518          * runlevels we assume the stop jobs will be implicitly added
3519          * by the core logic. Also, we don't really distinguish here
3520          * between the runlevels 0 and 6 and just add them to the
3521          * special shutdown target. On SUSE the boot.d/ runlevel is
3522          * also used for shutdown, so we add links for that too to the
3523          * shutdown target.*/
3524         SET_FOREACH(service, shutdown_services, j) {
3525                 service = unit_follow_merge(service);
3526
3527                 if (service->fragment_path)
3528                         continue;
3529
3530                 if ((r = unit_add_two_dependencies_by_name(service, UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true)) < 0)
3531                         goto finish;
3532         }
3533
3534         r = 0;
3535
3536 #ifdef TARGET_SUSE
3537         sysv_facility_in_insserv_conf (m);
3538 #endif
3539
3540 finish:
3541         free(path);
3542         free(fpath);
3543         free(name);
3544
3545         for (i = 0; i < ELEMENTSOF(rcnd_table); i++)
3546                 set_free(runlevel_services[i]);
3547         set_free(shutdown_services);
3548
3549         if (d)
3550                 closedir(d);
3551
3552         return r;
3553 }
3554 #endif
3555
3556 static void service_bus_name_owner_change(
3557                 Unit *u,
3558                 const char *name,
3559                 const char *old_owner,
3560                 const char *new_owner) {
3561
3562         Service *s = SERVICE(u);
3563
3564         assert(s);
3565         assert(name);
3566
3567         assert(streq(s->bus_name, name));
3568         assert(old_owner || new_owner);
3569
3570         if (old_owner && new_owner)
3571                 log_debug("%s's D-Bus name %s changed owner from %s to %s", u->id, name, old_owner, new_owner);
3572         else if (old_owner)
3573                 log_debug("%s's D-Bus name %s no longer registered by %s", u->id, name, old_owner);
3574         else
3575                 log_debug("%s's D-Bus name %s now registered by %s", u->id, name, new_owner);
3576
3577         s->bus_name_good = !!new_owner;
3578
3579         if (s->type == SERVICE_DBUS) {
3580
3581                 /* service_enter_running() will figure out what to
3582                  * do */
3583                 if (s->state == SERVICE_RUNNING)
3584                         service_enter_running(s, SERVICE_SUCCESS);
3585                 else if (s->state == SERVICE_START && new_owner)
3586                         service_enter_start_post(s);
3587
3588         } else if (new_owner &&
3589                    s->main_pid <= 0 &&
3590                    (s->state == SERVICE_START ||
3591                     s->state == SERVICE_START_POST ||
3592                     s->state == SERVICE_RUNNING ||
3593                     s->state == SERVICE_RELOAD)) {
3594
3595                 /* Try to acquire PID from bus service */
3596                 log_debug("Trying to acquire PID from D-Bus name...");
3597
3598                 bus_query_pid(u->manager, name);
3599         }
3600 }
3601
3602 static void service_bus_query_pid_done(
3603                 Unit *u,
3604                 const char *name,
3605                 pid_t pid) {
3606
3607         Service *s = SERVICE(u);
3608
3609         assert(s);
3610         assert(name);
3611
3612         log_debug("%s's D-Bus name %s is now owned by process %u", u->id, name, (unsigned) pid);
3613
3614         if (s->main_pid <= 0 &&
3615             (s->state == SERVICE_START ||
3616 &nb