]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/load-fragment.c
projects / thirdparty / systemd.git / blob
? search:


3440d9158f1c91df0b94c7eb4cec9305426fa06a
[thirdparty/systemd.git] / src / load-fragment.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <linux/oom.h>
23 #include <assert.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <sched.h>
29 #include <sys/prctl.h>
30 #include <sys/mount.h>
31 #include <linux/fs.h>
32 #include <sys/stat.h>
33 #include <sys/time.h>
34 #include <sys/resource.h>
35
36 #include "unit.h"
37 #include "strv.h"
38 #include "conf-parser.h"
39 #include "load-fragment.h"
40 #include "log.h"
41 #include "ioprio.h"
42 #include "securebits.h"
43 #include "missing.h"
44 #include "unit-name.h"
45 #include "bus-errors.h"
46
47 #ifndef HAVE_SYSV_COMPAT
48 static int config_parse_warn_compat(
49 const char *filename,
50 unsigned line,
51 const char *section,
52 const char *lvalue,
53 int ltype,
54 const char *rvalue,
55 void *data,
56 void *userdata) {
57
58 log_debug("[%s:%u] Support for option %s= has been disabled at compile time and is ignored", filename, line, lvalue);
59 return 0;
60 }
61 #endif
62
63 static int config_parse_deps(
64 const char *filename,
65 unsigned line,
66 const char *section,
67 const char *lvalue,
68 int ltype,
69 const char *rvalue,
70 void *data,
71 void *userdata) {
72
73 UnitDependency d = PTR_TO_UINT(data);
74 Unit *u = userdata;
75 char *w;
76 size_t l;
77 char *state;
78
79 assert(filename);
80 assert(lvalue);
81 assert(rvalue);
82
83 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
84 char *t, *k;
85 int r;
86
87 if (!(t = strndup(w, l)))
88 return -ENOMEM;
89
90 k = unit_name_printf(u, t);
91 free(t);
92
93 if (!k)
94 return -ENOMEM;
95
96 r = unit_add_dependency_by_name(u, d, k, NULL, true);
97
98 if (r < 0) {
99 log_error("Failed to add dependency on %s, ignoring: %s", k, strerror(-r));
100 free(k);
101 return 0;
102 }
103
104 free(k);
105 }
106
107 return 0;
108 }
109
110 static int config_parse_names(
111 const char *filename,
112 unsigned line,
113 const char *section,
114 const char *lvalue,
115 int ltype,
116 const char *rvalue,
117 void *data,
118 void *userdata) {
119
120 Unit *u = userdata;
121 char *w;
122 size_t l;
123 char *state;
124
125 assert(filename);
126 assert(lvalue);
127 assert(rvalue);
128 assert(data);
129
130 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
131 char *t, *k;
132 int r;
133
134 if (!(t = strndup(w, l)))
135 return -ENOMEM;
136
137 k = unit_name_printf(u, t);
138 free(t);
139
140 if (!k)
141 return -ENOMEM;
142
143 r = unit_merge_by_name(u, k);
144
145 if (r < 0) {
146 log_error("Failed to add name %s, ignoring: %s", k, strerror(-r));
147 free(k);
148 return 0;
149 }
150
151 free(k);
152 }
153
154 return 0;
155 }
156
157 static int config_parse_string_printf(
158 const char *filename,
159 unsigned line,
160 const char *section,
161 const char *lvalue,
162 int ltype,
163 const char *rvalue,
164 void *data,
165 void *userdata) {
166
167 Unit *u = userdata;
168 char **s = data;
169 char *k;
170
171 assert(filename);
172 assert(lvalue);
173 assert(rvalue);
174 assert(s);
175 assert(u);
176
177 if (!(k = unit_full_printf(u, rvalue)))
178 return -ENOMEM;
179
180 free(*s);
181 if (*k)
182 *s = k;
183 else {
184 free(k);
185 *s = NULL;
186 }
187
188 return 0;
189 }
190
191 static int config_parse_listen(
192 const char *filename,
193 unsigned line,
194 const char *section,
195 const char *lvalue,
196 int ltype,
197 const char *rvalue,
198 void *data,
199 void *userdata) {
200
201 SocketPort *p;
202 Socket *s;
203
204 assert(filename);
205 assert(lvalue);
206 assert(rvalue);
207 assert(data);
208
209 s = (Socket*) data;
210
211 if (!(p = new0(SocketPort, 1)))
212 return -ENOMEM;
213
214 if (streq(lvalue, "ListenFIFO")) {
215 p->type = SOCKET_FIFO;
216
217 if (!(p->path = strdup(rvalue))) {
218 free(p);
219 return -ENOMEM;
220 }
221
222 path_kill_slashes(p->path);
223 } else if (streq(lvalue, "ListenNetlink")) {
224 p->type = SOCKET_SOCKET;
225
226 if (socket_address_parse_netlink(&p->address, rvalue) < 0) {
227 log_error("[%s:%u] Failed to parse address value, ignoring: %s", filename, line, rvalue);
228 free(p);
229 return 0;
230 }
231
232 } else {
233 p->type = SOCKET_SOCKET;
234
235 if (socket_address_parse(&p->address, rvalue) < 0) {
236 log_error("[%s:%u] Failed to parse address value, ignoring: %s", filename, line, rvalue);
237 free(p);
238 return 0;
239 }
240
241 if (streq(lvalue, "ListenStream"))
242 p->address.type = SOCK_STREAM;
243 else if (streq(lvalue, "ListenDatagram"))
244 p->address.type = SOCK_DGRAM;
245 else {
246 assert(streq(lvalue, "ListenSequentialPacket"));
247 p->address.type = SOCK_SEQPACKET;
248 }
249
250 if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {
251 log_error("[%s:%u] Address family not supported, ignoring: %s", filename, line, rvalue);
252 free(p);
253 return 0;
254 }
255 }
256
257 p->fd = -1;
258 LIST_PREPEND(SocketPort, port, s->ports, p);
259
260 return 0;
261 }
262
263 static int config_parse_socket_bind(
264 const char *filename,
265 unsigned line,
266 const char *section,
267 const char *lvalue,
268 int ltype,
269 const char *rvalue,
270 void *data,
271 void *userdata) {
272
273 Socket *s;
274 SocketAddressBindIPv6Only b;
275
276 assert(filename);
277 assert(lvalue);
278 assert(rvalue);
279 assert(data);
280
281 s = (Socket*) data;
282
283 if ((b = socket_address_bind_ipv6_only_from_string(rvalue)) < 0) {
284 int r;
285
286 if ((r = parse_boolean(rvalue)) < 0) {
287 log_error("[%s:%u] Failed to parse bind IPv6 only value, ignoring: %s", filename, line, rvalue);
288 return 0;
289 }
290
291 s->bind_ipv6_only = r ? SOCKET_ADDRESS_IPV6_ONLY : SOCKET_ADDRESS_BOTH;
292 } else
293 s->bind_ipv6_only = b;
294
295 return 0;
296 }
297
298 static int config_parse_nice(
299 const char *filename,
300 unsigned line,
301 const char *section,
302 const char *lvalue,
303 int ltype,
304 const char *rvalue,
305 void *data,
306 void *userdata) {
307
308 ExecContext *c = data;
309 int priority;
310
311 assert(filename);
312 assert(lvalue);
313 assert(rvalue);
314 assert(data);
315
316 if (safe_atoi(rvalue, &priority) < 0) {
317 log_error("[%s:%u] Failed to parse nice priority, ignoring: %s. ", filename, line, rvalue);
318 return 0;
319 }
320
321 if (priority < PRIO_MIN || priority >= PRIO_MAX) {
322 log_error("[%s:%u] Nice priority out of range, ignoring: %s", filename, line, rvalue);
323 return 0;
324 }
325
326 c->nice = priority;
327 c->nice_set = true;
328
329 return 0;
330 }
331
332 static int config_parse_oom_score_adjust(
333 const char *filename,
334 unsigned line,
335 const char *section,
336 const char *lvalue,
337 int ltype,
338 const char *rvalue,
339 void *data,
340 void *userdata) {
341
342 ExecContext *c = data;
343 int oa;
344
345 assert(filename);
346 assert(lvalue);
347 assert(rvalue);
348 assert(data);
349
350 if (safe_atoi(rvalue, &oa) < 0) {
351 log_error("[%s:%u] Failed to parse the OOM score adjust value, ignoring: %s", filename, line, rvalue);
352 return 0;
353 }
354
355 if (oa < OOM_SCORE_ADJ_MIN || oa > OOM_SCORE_ADJ_MAX) {
356 log_error("[%s:%u] OOM score adjust value out of range, ignoring: %s", filename, line, rvalue);
357 return 0;
358 }
359
360 c->oom_score_adjust = oa;
361 c->oom_score_adjust_set = true;
362
363 return 0;
364 }
365
366 static int config_parse_mode(
367 const char *filename,
368 unsigned line,
369 const char *section,
370 const char *lvalue,
371 int ltype,
372 const char *rvalue,
373 void *data,
374 void *userdata) {
375
376 mode_t *m = data;
377 long l;
378 char *x = NULL;
379
380 assert(filename);
381 assert(lvalue);
382 assert(rvalue);
383 assert(data);
384
385 errno = 0;
386 l = strtol(rvalue, &x, 8);
387 if (!x || *x || errno) {
388 log_error("[%s:%u] Failed to parse mode value, ignoring: %s", filename, line, rvalue);
389 return 0;
390 }
391
392 if (l < 0000 || l > 07777) {
393 log_error("[%s:%u] mode value out of range, ignoring: %s", filename, line, rvalue);
394 return 0;
395 }
396
397 *m = (mode_t) l;
398 return 0;
399 }
400
401 static int config_parse_exec(
402 const char *filename,
403 unsigned line,
404 const char *section,
405 const char *lvalue,
406 int ltype,
407 const char *rvalue,
408 void *data,
409 void *userdata) {
410
411 ExecCommand **e = data, *nce;
412 char *path, **n;
413 unsigned k;
414
415 assert(filename);
416 assert(lvalue);
417 assert(rvalue);
418 assert(e);
419
420 /* We accept an absolute path as first argument, or
421 * alternatively an absolute prefixed with @ to allow
422 * overriding of argv[0]. */
423
424 for (;;) {
425 char *w;
426 size_t l;
427 char *state;
428 bool honour_argv0 = false, ignore = false;
429
430 path = NULL;
431 nce = NULL;
432 n = NULL;
433
434 rvalue += strspn(rvalue, WHITESPACE);
435
436 if (rvalue[0] == 0)
437 break;
438
439 if (rvalue[0] == '-') {
440 ignore = true;
441 rvalue ++;
442 }
443
444 if (rvalue[0] == '@') {
445 honour_argv0 = true;
446 rvalue ++;
447 }
448
449 if (*rvalue != '/') {
450 log_error("[%s:%u] Invalid executable path in command line, ignoring: %s", filename, line, rvalue);
451 return 0;
452 }
453
454 k = 0;
455 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
456 if (strncmp(w, ";", MAX(l, 1U)) == 0)
457 break;
458
459 k++;
460 }
461
462 if (!(n = new(char*, k + !honour_argv0)))
463 return -ENOMEM;
464
465 k = 0;
466 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
467 if (strncmp(w, ";", MAX(l, 1U)) == 0)
468 break;
469
470 if (honour_argv0 && w == rvalue) {
471 assert(!path);
472 if (!(path = cunescape_length(w, l)))
473 goto fail;
474 } else {
475 if (!(n[k++] = cunescape_length(w, l)))
476 goto fail;
477 }
478 }
479
480 n[k] = NULL;
481
482 if (!n[0]) {
483 log_error("[%s:%u] Invalid command line, ignoring: %s", filename, line, rvalue);
484 strv_free(n);
485 return 0;
486 }
487
488 if (!path)
489 if (!(path = strdup(n[0])))
490 goto fail;
491
492 assert(path_is_absolute(path));
493
494 if (!(nce = new0(ExecCommand, 1)))
495 goto fail;
496
497 nce->argv = n;
498 nce->path = path;
499 nce->ignore = ignore;
500
501 path_kill_slashes(nce->path);
502
503 exec_command_append_list(e, nce);
504
505 rvalue = state;
506 }
507
508 return 0;
509
510 fail:
511 n[k] = NULL;
512 strv_free(n);
513 free(path);
514 free(nce);
515
516 return -ENOMEM;
517 }
518
519 static int config_parse_usec(
520 const char *filename,
521 unsigned line,
522 const char *section,
523 const char *lvalue,
524 int ltype,
525 const char *rvalue,
526 void *data,
527 void *userdata) {
528
529 usec_t *usec = data;
530
531 assert(filename);
532 assert(lvalue);
533 assert(rvalue);
534 assert(data);
535
536 if (parse_usec(rvalue, usec) < 0) {
537 log_error("[%s:%u] Failed to parse time value, ignoring: %s", filename, line, rvalue);
538 return 0;
539 }
540
541 return 0;
542 }
543
544 static DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type");
545 static DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier");
546
547 static int config_parse_bindtodevice(
548 const char *filename,
549 unsigned line,
550 const char *section,
551 const char *lvalue,
552 int ltype,
553 const char *rvalue,
554 void *data,
555 void *userdata) {
556
557 Socket *s = data;
558 char *n;
559
560 assert(filename);
561 assert(lvalue);
562 assert(rvalue);
563 assert(data);
564
565 if (rvalue[0] && !streq(rvalue, "*")) {
566 if (!(n = strdup(rvalue)))
567 return -ENOMEM;
568 } else
569 n = NULL;
570
571 free(s->bind_to_device);
572 s->bind_to_device = n;
573
574 return 0;
575 }
576
577 static DEFINE_CONFIG_PARSE_ENUM(config_parse_output, exec_output, ExecOutput, "Failed to parse output specifier");
578 static DEFINE_CONFIG_PARSE_ENUM(config_parse_input, exec_input, ExecInput, "Failed to parse input specifier");
579
580 static int config_parse_facility(
581 const char *filename,
582 unsigned line,
583 const char *section,
584 const char *lvalue,
585 int ltype,
586 const char *rvalue,
587 void *data,
588 void *userdata) {
589
590
591 int *o = data, x;
592
593 assert(filename);
594 assert(lvalue);
595 assert(rvalue);
596 assert(data);
597
598 if ((x = log_facility_unshifted_from_string(rvalue)) < 0) {
599 log_error("[%s:%u] Failed to parse log facility, ignoring: %s", filename, line, rvalue);
600 return 0;
601 }
602
603 *o = (x << 3) | LOG_PRI(*o);
604
605 return 0;
606 }
607
608 static int config_parse_level(
609 const char *filename,
610 unsigned line,
611 const char *section,
612 const char *lvalue,
613 int ltype,
614 const char *rvalue,
615 void *data,
616 void *userdata) {
617
618
619 int *o = data, x;
620
621 assert(filename);
622 assert(lvalue);
623 assert(rvalue);
624 assert(data);
625
626 if ((x = log_level_from_string(rvalue)) < 0) {
627 log_error("[%s:%u] Failed to parse log level, ignoring: %s", filename, line, rvalue);
628 return 0;
629 }
630
631 *o = (*o & LOG_FACMASK) | x;
632 return 0;
633 }
634
635 static int config_parse_io_class(
636 const char *filename,
637 unsigned line,
638 const char *section,
639 const char *lvalue,
640 int ltype,
641 const char *rvalue,
642 void *data,
643 void *userdata) {
644
645 ExecContext *c = data;
646 int x;
647
648 assert(filename);
649 assert(lvalue);
650 assert(rvalue);
651 assert(data);
652
653 if ((x = ioprio_class_from_string(rvalue)) < 0) {
654 log_error("[%s:%u] Failed to parse IO scheduling class, ignoring: %s", filename, line, rvalue);
655 return 0;
656 }
657
658 c->ioprio = IOPRIO_PRIO_VALUE(x, IOPRIO_PRIO_DATA(c->ioprio));
659 c->ioprio_set = true;
660
661 return 0;
662 }
663
664 static int config_parse_io_priority(
665 const char *filename,
666 unsigned line,
667 const char *section,
668 const char *lvalue,
669 int ltype,
670 const char *rvalue,
671 void *data,
672 void *userdata) {
673
674 ExecContext *c = data;
675 int i;
676
677 assert(filename);
678 assert(lvalue);
679 assert(rvalue);
680 assert(data);
681
682 if (safe_atoi(rvalue, &i) < 0 || i < 0 || i >= IOPRIO_BE_NR) {
683 log_error("[%s:%u] Failed to parse io priority, ignoring: %s", filename, line, rvalue);
684 return 0;
685 }
686
687 c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_PRIO_CLASS(c->ioprio), i);
688 c->ioprio_set = true;
689
690 return 0;
691 }
692
693 static int config_parse_cpu_sched_policy(
694 const char *filename,
695 unsigned line,
696 const char *section,
697 const char *lvalue,
698 int ltype,
699 const char *rvalue,
700 void *data,
701 void *userdata) {
702
703
704 ExecContext *c = data;
705 int x;
706
707 assert(filename);
708 assert(lvalue);
709 assert(rvalue);
710 assert(data);
711
712 if ((x = sched_policy_from_string(rvalue)) < 0) {
713 log_error("[%s:%u] Failed to parse CPU scheduling policy, ignoring: %s", filename, line, rvalue);
714 return 0;
715 }
716
717 c->cpu_sched_policy = x;
718 c->cpu_sched_set = true;
719
720 return 0;
721 }
722
723 static int config_parse_cpu_sched_prio(
724 const char *filename,
725 unsigned line,
726 const char *section,
727 const char *lvalue,
728 int ltype,
729 const char *rvalue,
730 void *data,
731 void *userdata) {
732
733 ExecContext *c = data;
734 int i;
735
736 assert(filename);
737 assert(lvalue);
738 assert(rvalue);
739 assert(data);
740
741 /* On Linux RR/FIFO have the same range */
742 if (safe_atoi(rvalue, &i) < 0 || i < sched_get_priority_min(SCHED_RR) || i > sched_get_priority_max(SCHED_RR)) {
743 log_error("[%s:%u] Failed to parse CPU scheduling priority, ignoring: %s", filename, line, rvalue);
744 return 0;
745 }
746
747 c->cpu_sched_priority = i;
748 c->cpu_sched_set = true;
749
750 return 0;
751 }
752
753 static int config_parse_cpu_affinity(
754 const char *filename,
755 unsigned line,
756 const char *section,
757 const char *lvalue,
758 int ltype,
759 const char *rvalue,
760 void *data,
761 void *userdata) {
762
763 ExecContext *c = data;
764 char *w;
765 size_t l;
766 char *state;
767
768 assert(filename);
769 assert(lvalue);
770 assert(rvalue);
771 assert(data);
772
773 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
774 char *t;
775 int r;
776 unsigned cpu;
777
778 if (!(t = strndup(w, l)))
779 return -ENOMEM;
780
781 r = safe_atou(t, &cpu);
782 free(t);
783
784 if (!(c->cpuset))
785 if (!(c->cpuset = cpu_set_malloc(&c->cpuset_ncpus)))
786 return -ENOMEM;
787
788 if (r < 0 || cpu >= c->cpuset_ncpus) {
789 log_error("[%s:%u] Failed to parse CPU affinity, ignoring: %s", filename, line, rvalue);
790 return 0;
791 }
792
793 CPU_SET_S(cpu, CPU_ALLOC_SIZE(c->cpuset_ncpus), c->cpuset);
794 }
795
796 return 0;
797 }
798
799 static int config_parse_capabilities(
800 const char *filename,
801 unsigned line,
802 const char *section,
803 const char *lvalue,
804 int ltype,
805 const char *rvalue,
806 void *data,
807 void *userdata) {
808
809 ExecContext *c = data;
810 cap_t cap;
811
812 assert(filename);
813 assert(lvalue);
814 assert(rvalue);
815 assert(data);
816
817 if (!(cap = cap_from_text(rvalue))) {
818 if (errno == ENOMEM)
819 return -ENOMEM;
820
821 log_error("[%s:%u] Failed to parse capabilities, ignoring: %s", filename, line, rvalue);
822 return 0;
823 }
824
825 if (c->capabilities)
826 cap_free(c->capabilities);
827 c->capabilities = cap;
828
829 return 0;
830 }
831
832 static int config_parse_secure_bits(
833 const char *filename,
834 unsigned line,
835 const char *section,
836 const char *lvalue,
837 int ltype,
838 const char *rvalue,
839 void *data,
840 void *userdata) {
841
842 ExecContext *c = data;
843 char *w;
844 size_t l;
845 char *state;
846
847 assert(filename);
848 assert(lvalue);
849 assert(rvalue);
850 assert(data);
851
852 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
853 if (first_word(w, "keep-caps"))
854 c->secure_bits |= SECURE_KEEP_CAPS;
855 else if (first_word(w, "keep-caps-locked"))
856 c->secure_bits |= SECURE_KEEP_CAPS_LOCKED;
857 else if (first_word(w, "no-setuid-fixup"))
858 c->secure_bits |= SECURE_NO_SETUID_FIXUP;
859 else if (first_word(w, "no-setuid-fixup-locked"))
860 c->secure_bits |= SECURE_NO_SETUID_FIXUP_LOCKED;
861 else if (first_word(w, "noroot"))
862 c->secure_bits |= SECURE_NOROOT;
863 else if (first_word(w, "noroot-locked"))
864 c->secure_bits |= SECURE_NOROOT_LOCKED;
865 else {
866 log_error("[%s:%u] Failed to parse secure bits, ignoring: %s", filename, line, rvalue);
867 return 0;
868 }
869 }
870
871 return 0;
872 }
873
874 static int config_parse_bounding_set(
875 const char *filename,
876 unsigned line,
877 const char *section,
878 const char *lvalue,
879 int ltype,
880 const char *rvalue,
881 void *data,
882 void *userdata) {
883
884 ExecContext *c = data;
885 char *w;
886 size_t l;
887 char *state;
888 bool invert = false;
889 uint64_t sum = 0;
890
891 assert(filename);
892 assert(lvalue);
893 assert(rvalue);
894 assert(data);
895
896 if (rvalue[0] == '~') {
897 invert = true;
898 rvalue++;
899 }
900
901 /* Note that we store this inverted internally, since the
902 * kernel wants it like this. But we actually expose it
903 * non-inverted everywhere to have a fully normalized
904 * interface. */
905
906 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
907 char *t;
908 int r;
909 cap_value_t cap;
910
911 if (!(t = strndup(w, l)))
912 return -ENOMEM;
913
914 r = cap_from_name(t, &cap);
915 free(t);
916
917 if (r < 0) {
918 log_error("[%s:%u] Failed to parse capability bounding set, ignoring: %s", filename, line, rvalue);
919 return 0;
920 }
921
922 sum |= ((uint64_t) 1ULL) << (uint64_t) cap;
923 }
924
925 if (invert)
926 c->capability_bounding_set_drop |= sum;
927 else
928 c->capability_bounding_set_drop |= ~sum;
929
930 return 0;
931 }
932
933 static int config_parse_timer_slack_nsec(
934 const char *filename,
935 unsigned line,
936 const char *section,
937 const char *lvalue,
938 int ltype,
939 const char *rvalue,
940 void *data,
941 void *userdata) {
942
943 ExecContext *c = data;
944 unsigned long u;
945
946 assert(filename);
947 assert(lvalue);
948 assert(rvalue);
949 assert(data);
950
951 if (safe_atolu(rvalue, &u) < 0) {
952 log_error("[%s:%u] Failed to parse time slack value, ignoring: %s", filename, line, rvalue);
953 return 0;
954 }
955
956 c->timer_slack_nsec = u;
957
958 return 0;
959 }
960
961 static int config_parse_limit(
962 const char *filename,
963 unsigned line,
964 const char *section,
965 const char *lvalue,
966 int ltype,
967 const char *rvalue,
968 void *data,
969 void *userdata) {
970
971 struct rlimit **rl = data;
972 unsigned long long u;
973
974 assert(filename);
975 assert(lvalue);
976 assert(rvalue);
977 assert(data);
978
979 if (streq(rvalue, "infinity"))
980 u = (unsigned long long) RLIM_INFINITY;
981 else if (safe_atollu(rvalue, &u) < 0) {
982 log_error("[%s:%u] Failed to parse resource value, ignoring: %s", filename, line, rvalue);
983 return 0;
984 }
985
986 if (!*rl)
987 if (!(*rl = new(struct rlimit, 1)))
988 return -ENOMEM;
989
990 (*rl)->rlim_cur = (*rl)->rlim_max = (rlim_t) u;
991 return 0;
992 }
993
994 static int config_parse_cgroup(
995 const char *filename,
996 unsigned line,
997 const char *section,
998 const char *lvalue,
999 int ltype,
1000 const char *rvalue,
1001 void *data,
1002 void *userdata) {
1003
1004 Unit *u = userdata;
1005 char *w;
1006 size_t l;
1007 char *state;
1008
1009 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
1010 char *t;
1011 int r;
1012
1013 if (!(t = cunescape_length(w, l)))
1014 return -ENOMEM;
1015
1016 r = unit_add_cgroup_from_text(u, t);
1017 free(t);
1018
1019 if (r < 0) {
1020 log_error("[%s:%u] Failed to parse cgroup value, ignoring: %s", filename, line, rvalue);
1021 return 0;
1022 }
1023 }
1024
1025 return 0;
1026 }
1027
1028 #ifdef HAVE_SYSV_COMPAT
1029 static int config_parse_sysv_priority(
1030 const char *filename,
1031 unsigned line,
1032 const char *section,
1033 const char *lvalue,
1034 int ltype,
1035 const char *rvalue,
1036 void *data,
1037 void *userdata) {
1038
1039 int *priority = data;
1040 int i;
1041
1042 assert(filename);
1043 assert(lvalue);
1044 assert(rvalue);
1045 assert(data);
1046
1047 if (safe_atoi(rvalue, &i) < 0 || i < 0) {
1048 log_error("[%s:%u] Failed to parse SysV start priority, ignoring: %s", filename, line, rvalue);
1049 return 0;
1050 }
1051
1052 *priority = (int) i;
1053 return 0;
1054 }
1055 #endif
1056
1057 static int config_parse_fsck_passno(
1058 const char *filename,
1059 unsigned line,
1060 const char *section,
1061 const char *lvalue,
1062 int ltype,
1063 const char *rvalue,
1064 void *data,
1065 void *userdata) {
1066
1067 int *passno = data;
1068 int i;
1069
1070 assert(filename);
1071 assert(lvalue);
1072 assert(rvalue);
1073 assert(data);
1074
1075 if (safe_atoi(rvalue, &i) || i < 0) {
1076 log_error("[%s:%u] Failed to parse fsck pass number, ignoring: %s", filename, line, rvalue);
1077 return 0;
1078 }
1079
1080 *passno = (int) i;
1081 return 0;
1082 }
1083
1084 static DEFINE_CONFIG_PARSE_ENUM(config_parse_kill_mode, kill_mode, KillMode, "Failed to parse kill mode");
1085
1086 static int config_parse_kill_signal(
1087 const char *filename,
1088 unsigned line,
1089 const char *section,
1090 const char *lvalue,
1091 int ltype,
1092 const char *rvalue,
1093 void *data,
1094 void *userdata) {
1095
1096 int *sig = data;
1097 int r;
1098
1099 assert(filename);
1100 assert(lvalue);
1101 assert(rvalue);
1102 assert(sig);
1103
1104 if ((r = signal_from_string_try_harder(rvalue)) <= 0) {
1105 log_error("[%s:%u] Failed to parse kill signal, ignoring: %s", filename, line, rvalue);
1106 return 0;
1107 }
1108
1109 *sig = r;
1110 return 0;
1111 }
1112
1113 static int config_parse_mount_flags(
1114 const char *filename,
1115 unsigned line,
1116 const char *section,
1117 const char *lvalue,
1118 int ltype,
1119 const char *rvalue,
1120 void *data,
1121 void *userdata) {
1122
1123 ExecContext *c = data;
1124 char *w;
1125 size_t l;
1126 char *state;
1127 unsigned long flags = 0;
1128
1129 assert(filename);
1130 assert(lvalue);
1131 assert(rvalue);
1132 assert(data);
1133
1134 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
1135 if (strncmp(w, "shared", MAX(l, 6U)) == 0)
1136 flags |= MS_SHARED;
1137 else if (strncmp(w, "slave", MAX(l, 5U)) == 0)
1138 flags |= MS_SLAVE;
1139 else if (strncmp(w, "private", MAX(l, 7U)) == 0)
1140 flags |= MS_PRIVATE;
1141 else {
1142 log_error("[%s:%u] Failed to parse mount flags, ignoring: %s", filename, line, rvalue);
1143 return 0;
1144 }
1145 }
1146
1147 c->mount_flags = flags;
1148 return 0;
1149 }
1150
1151 static int config_parse_timer(
1152 const char *filename,
1153 unsigned line,
1154 const char *section,
1155 const char *lvalue,
1156 int ltype,
1157 const char *rvalue,
1158 void *data,
1159 void *userdata) {
1160
1161 Timer *t = data;
1162 usec_t u;
1163 TimerValue *v;
1164 TimerBase b;
1165
1166 assert(filename);
1167 assert(lvalue);
1168 assert(rvalue);
1169 assert(data);
1170
1171 if ((b = timer_base_from_string(lvalue)) < 0) {
1172 log_error("[%s:%u] Failed to parse timer base, ignoring: %s", filename, line, lvalue);
1173 return 0;
1174 }
1175
1176 if (parse_usec(rvalue, &u) < 0) {
1177 log_error("[%s:%u] Failed to parse timer value, ignoring: %s", filename, line, rvalue);
1178 return 0;
1179 }
1180
1181 if (!(v = new0(TimerValue, 1)))
1182 return -ENOMEM;
1183
1184 v->base = b;
1185 v->value = u;
1186
1187 LIST_PREPEND(TimerValue, value, t->values, v);
1188
1189 return 0;
1190 }
1191
1192 static int config_parse_timer_unit(
1193 const char *filename,
1194 unsigned line,
1195 const char *section,
1196 const char *lvalue,
1197 int ltype,
1198 const char *rvalue,
1199 void *data,
1200 void *userdata) {
1201
1202 Timer *t = data;
1203 int r;
1204 DBusError error;
1205
1206 assert(filename);
1207 assert(lvalue);
1208 assert(rvalue);
1209 assert(data);
1210
1211 dbus_error_init(&error);
1212
1213 if (endswith(rvalue, ".timer")) {
1214 log_error("[%s:%u] Unit cannot be of type timer, ignoring: %s", filename, line, rvalue);
1215 return 0;
1216 }
1217
1218 if ((r = manager_load_unit(t->meta.manager, rvalue, NULL, NULL, &t->unit)) < 0) {
1219 log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r));
1220 dbus_error_free(&error);
1221 return 0;
1222 }
1223
1224 return 0;
1225 }
1226
1227 static int config_parse_path_spec(
1228 const char *filename,
1229 unsigned line,
1230 const char *section,
1231 const char *lvalue,
1232 int ltype,
1233 const char *rvalue,
1234 void *data,
1235 void *userdata) {
1236
1237 Path *p = data;
1238 PathSpec *s;
1239 PathType b;
1240
1241 assert(filename);
1242 assert(lvalue);
1243 assert(rvalue);
1244 assert(data);
1245
1246 if ((b = path_type_from_string(lvalue)) < 0) {
1247 log_error("[%s:%u] Failed to parse path type, ignoring: %s", filename, line, lvalue);
1248 return 0;
1249 }
1250
1251 if (!path_is_absolute(rvalue)) {
1252 log_error("[%s:%u] Path is not absolute, ignoring: %s", filename, line, rvalue);
1253 return 0;
1254 }
1255
1256 if (!(s = new0(PathSpec, 1)))
1257 return -ENOMEM;
1258
1259 if (!(s->path = strdup(rvalue))) {
1260 free(s);
1261 return -ENOMEM;
1262 }
1263
1264 path_kill_slashes(s->path);
1265
1266 s->type = b;
1267 s->inotify_fd = -1;
1268
1269 LIST_PREPEND(PathSpec, spec, p->specs, s);
1270
1271 return 0;
1272 }
1273
1274 static int config_parse_path_unit(
1275 const char *filename,
1276 unsigned line,
1277 const char *section,
1278 const char *lvalue,
1279 int ltype,
1280 const char *rvalue,
1281 void *data,
1282 void *userdata) {
1283
1284 Path *t = data;
1285 int r;
1286 DBusError error;
1287
1288 assert(filename);
1289 assert(lvalue);
1290 assert(rvalue);
1291 assert(data);
1292
1293 dbus_error_init(&error);
1294
1295 if (endswith(rvalue, ".path")) {
1296 log_error("[%s:%u] Unit cannot be of type path, ignoring: %s", filename, line, rvalue);
1297 return 0;
1298 }
1299
1300 if ((r = manager_load_unit(t->meta.manager, rvalue, NULL, &error, &t->unit)) < 0) {
1301 log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r));
1302 dbus_error_free(&error);
1303 return 0;
1304 }
1305
1306 return 0;
1307 }
1308
1309 static int config_parse_socket_service(
1310 const char *filename,
1311 unsigned line,
1312 const char *section,
1313 const char *lvalue,
1314 int ltype,
1315 const char *rvalue,
1316 void *data,
1317 void *userdata) {
1318
1319 Socket *s = data;
1320 int r;
1321 DBusError error;
1322
1323 assert(filename);
1324 assert(lvalue);
1325 assert(rvalue);
1326 assert(data);
1327
1328 dbus_error_init(&error);
1329
1330 if (!endswith(rvalue, ".service")) {
1331 log_error("[%s:%u] Unit must be of type service, ignoring: %s", filename, line, rvalue);
1332 return 0;
1333 }
1334
1335 if ((r = manager_load_unit(s->meta.manager, rvalue, NULL, &error, (Unit**) &s->service)) < 0) {
1336 log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r));
1337 dbus_error_free(&error);
1338 return 0;
1339 }
1340
1341 return 0;
1342 }
1343
1344 static int config_parse_service_sockets(
1345 const char *filename,
1346 unsigned line,
1347 const char *section,
1348 const char *lvalue,
1349 int ltype,
1350 const char *rvalue,
1351 void *data,
1352 void *userdata) {
1353
1354 Service *s = data;
1355 int r;
1356 DBusError error;
1357 char *state, *w;
1358 size_t l;
1359
1360 assert(filename);
1361 assert(lvalue);
1362 assert(rvalue);
1363 assert(data);
1364
1365 dbus_error_init(&error);
1366
1367 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
1368 char *t;
1369 Unit *sock;
1370
1371 if (!(t = strndup(w, l)))
1372 return -ENOMEM;
1373
1374 if (!endswith(t, ".socket")) {
1375 log_error("[%s:%u] Unit must be of type socket, ignoring: %s", filename, line, rvalue);
1376 free(t);
1377 continue;
1378 }
1379
1380 r = manager_load_unit(s->meta.manager, t, NULL, &error, &sock);
1381 free(t);
1382
1383 if (r < 0) {
1384 log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r));
1385 dbus_error_free(&error);
1386 continue;
1387 }
1388
1389 if ((r = set_ensure_allocated(&s->configured_sockets, trivial_hash_func, trivial_compare_func)) < 0)
1390 return r;
1391
1392 if ((r = set_put(s->configured_sockets, sock)) < 0)
1393 return r;
1394 }
1395
1396 return 0;
1397 }
1398
1399 static int config_parse_env_file(
1400 const char *filename,
1401 unsigned line,
1402 const char *section,
1403 const char *lvalue,
1404 int ltype,
1405 const char *rvalue,
1406 void *data,
1407 void *userdata) {
1408
1409 char ***env = data, **k;
1410
1411 assert(filename);
1412 assert(lvalue);
1413 assert(rvalue);
1414 assert(data);
1415
1416 if (!path_is_absolute(rvalue[0] == '-' ? rvalue + 1 : rvalue)) {
1417 log_error("[%s:%u] Path '%s' is not absolute, ignoring.", filename, line, rvalue);
1418 return 0;
1419 }
1420
1421 if (!(k = strv_append(*env, rvalue)))
1422 return -ENOMEM;
1423
1424 strv_free(*env);
1425 *env = k;
1426
1427 return 0;
1428 }
1429
1430 static int config_parse_ip_tos(
1431 const char *filename,
1432 unsigned line,
1433 const char *section,
1434 const char *lvalue,
1435 int ltype,
1436 const char *rvalue,
1437 void *data,
1438 void *userdata) {
1439
1440 int *ip_tos = data, x;
1441
1442 assert(filename);
1443 assert(lvalue);
1444 assert(rvalue);
1445 assert(data);
1446
1447 if ((x = ip_tos_from_string(rvalue)) < 0)
1448 if (safe_atoi(rvalue, &x) < 0) {
1449 log_error("[%s:%u] Failed to parse IP TOS value, ignoring: %s", filename, line, rvalue);
1450 return 0;
1451 }
1452
1453 *ip_tos = x;
1454 return 0;
1455 }
1456
1457 static int config_parse_condition_path(
1458 const char *filename,
1459 unsigned line,
1460 const char *section,
1461 const char *lvalue,
1462 int ltype,
1463 const char *rvalue,
1464 void *data,
1465 void *userdata) {
1466
1467 ConditionType cond = ltype;
1468 Unit *u = data;
1469 bool trigger, negate;
1470 Condition *c;
1471
1472 assert(filename);
1473 assert(lvalue);
1474 assert(rvalue);
1475 assert(data);
1476
1477 if ((trigger = rvalue[0] == '|'))
1478 rvalue++;
1479
1480 if ((negate = rvalue[0] == '!'))
1481 rvalue++;
1482
1483 if (!path_is_absolute(rvalue)) {
1484 log_error("[%s:%u] Path in condition not absolute, ignoring: %s", filename, line, rvalue);
1485 return 0;
1486 }
1487
1488 if (!(c = condition_new(cond, rvalue, trigger, negate)))
1489 return -ENOMEM;
1490
1491 LIST_PREPEND(Condition, conditions, u->meta.conditions, c);
1492 return 0;
1493 }
1494
1495 static int config_parse_condition_string(
1496 const char *filename,
1497 unsigned line,
1498 const char *section,
1499 const char *lvalue,
1500 int ltype,
1501 const char *rvalue,
1502 void *data,
1503 void *userdata) {
1504
1505 ConditionType cond = ltype;
1506 Unit *u = data;
1507 bool trigger, negate;
1508 Condition *c;
1509
1510 assert(filename);
1511 assert(lvalue);
1512 assert(rvalue);
1513 assert(data);
1514
1515 if ((trigger = rvalue[0] == '|'))
1516 rvalue++;
1517
1518 if ((negate = rvalue[0] == '!'))
1519 rvalue++;
1520
1521 if (!(c = condition_new(cond, rvalue, trigger, negate)))
1522 return -ENOMEM;
1523
1524 LIST_PREPEND(Condition, conditions, u->meta.conditions, c);
1525 return 0;
1526 }
1527
1528 static int config_parse_condition_null(
1529 const char *filename,
1530 unsigned line,
1531 const char *section,
1532 const char *lvalue,
1533 int ltype,
1534 const char *rvalue,
1535 void *data,
1536 void *userdata) {
1537
1538 Unit *u = data;
1539 Condition *c;
1540 bool trigger, negate;
1541 int b;
1542
1543 assert(filename);
1544 assert(lvalue);
1545 assert(rvalue);
1546 assert(data);
1547
1548 if ((trigger = rvalue[0] == '|'))
1549 rvalue++;
1550
1551 if ((negate = rvalue[0] == '!'))
1552 rvalue++;
1553
1554 if ((b = parse_boolean(rvalue)) < 0) {
1555 log_error("[%s:%u] Failed to parse boolean value in condition, ignoring: %s", filename, line, rvalue);
1556 return 0;
1557 }
1558
1559 if (!b)
1560 negate = !negate;
1561
1562 if (!(c = condition_new(CONDITION_NULL, NULL, trigger, negate)))
1563 return -ENOMEM;
1564
1565 LIST_PREPEND(Condition, conditions, u->meta.conditions, c);
1566 return 0;
1567 }
1568
1569 static DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier");
1570
1571 #define FOLLOW_MAX 8
1572
1573 static int open_follow(char **filename, FILE **_f, Set *names, char **_final) {
1574 unsigned c = 0;
1575 int fd, r;
1576 FILE *f;
1577 char *id = NULL;
1578
1579 assert(filename);
1580 assert(*filename);
1581 assert(_f);
1582 assert(names);
1583
1584 /* This will update the filename pointer if the loaded file is
1585 * reached by a symlink. The old string will be freed. */
1586
1587 for (;;) {
1588 char *target, *name;
1589
1590 if (c++ >= FOLLOW_MAX)
1591 return -ELOOP;
1592
1593 path_kill_slashes(*filename);
1594
1595 /* Add the file name we are currently looking at to
1596 * the names of this unit, but only if it is a valid
1597 * unit name. */
1598 name = file_name_from_path(*filename);
1599
1600 if (unit_name_is_valid(name, false)) {
1601 if (!(id = set_get(names, name))) {
1602
1603 if (!(id = strdup(name)))
1604 return -ENOMEM;
1605
1606 if ((r = set_put(names, id)) < 0) {
1607 free(id);
1608 return r;
1609 }
1610 }
1611 }
1612
1613 /* Try to open the file name, but don't if its a symlink */
1614 if ((fd = open(*filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW)) >= 0)
1615 break;
1616
1617 if (errno != ELOOP)
1618 return -errno;
1619
1620 /* Hmm, so this is a symlink. Let's read the name, and follow it manually */
1621 if ((r = readlink_and_make_absolute(*filename, &target)) < 0)
1622 return r;
1623
1624 free(*filename);
1625 *filename = target;
1626 }
1627
1628 if (!(f = fdopen(fd, "re"))) {
1629 r = -errno;
1630 close_nointr_nofail(fd);
1631 return r;
1632 }
1633
1634 *_f = f;
1635 *_final = id;
1636 return 0;
1637 }
1638
1639 static int merge_by_names(Unit **u, Set *names, const char *id) {
1640 char *k;
1641 int r;
1642
1643 assert(u);
1644 assert(*u);
1645 assert(names);
1646
1647 /* Let's try to add in all symlink names we found */
1648 while ((k = set_steal_first(names))) {
1649
1650 /* First try to merge in the other name into our
1651 * unit */
1652 if ((r = unit_merge_by_name(*u, k)) < 0) {
1653 Unit *other;
1654
1655 /* Hmm, we couldn't merge the other unit into
1656 * ours? Then let's try it the other way
1657 * round */
1658
1659 other = manager_get_unit((*u)->meta.manager, k);
1660 free(k);
1661
1662 if (other)
1663 if ((r = unit_merge(other, *u)) >= 0) {
1664 *u = other;
1665 return merge_by_names(u, names, NULL);
1666 }
1667
1668 return r;
1669 }
1670
1671 if (id == k)
1672 unit_choose_id(*u, id);
1673
1674 free(k);
1675 }
1676
1677 return 0;
1678 }
1679
1680 static void dump_items(FILE *f, const ConfigItem *items) {
1681 const ConfigItem *i;
1682 const char *prev_section = NULL;
1683 bool not_first = false;
1684
1685 struct {
1686 ConfigParserCallback callback;
1687 const char *rvalue;
1688 } table[] = {
1689 { config_parse_int, "INTEGER" },
1690 { config_parse_unsigned, "UNSIGNED" },
1691 { config_parse_size, "SIZE" },
1692 { config_parse_bool, "BOOLEAN" },
1693 { config_parse_string, "STRING" },
1694 { config_parse_path, "PATH" },
1695 { config_parse_strv, "STRING [...]" },
1696 { config_parse_nice, "NICE" },
1697 { config_parse_oom_score_adjust, "OOMSCOREADJUST" },
1698 { config_parse_io_class, "IOCLASS" },
1699 { config_parse_io_priority, "IOPRIORITY" },
1700 { config_parse_cpu_sched_policy, "CPUSCHEDPOLICY" },
1701 { config_parse_cpu_sched_prio, "CPUSCHEDPRIO" },
1702 { config_parse_cpu_affinity, "CPUAFFINITY" },
1703 { config_parse_mode, "MODE" },
1704 { config_parse_env_file, "FILE" },
1705 { config_parse_output, "OUTPUT" },
1706 { config_parse_input, "INPUT" },
1707 { config_parse_facility, "FACILITY" },
1708 { config_parse_level, "LEVEL" },
1709 { config_parse_capabilities, "CAPABILITIES" },
1710 { config_parse_secure_bits, "SECUREBITS" },
1711 { config_parse_bounding_set, "BOUNDINGSET" },
1712 { config_parse_timer_slack_nsec, "TIMERSLACK" },
1713 { config_parse_limit, "LIMIT" },
1714 { config_parse_cgroup, "CGROUP [...]" },
1715 { config_parse_deps, "UNIT [...]" },
1716 { config_parse_names, "UNIT [...]" },
1717 { config_parse_exec, "PATH [ARGUMENT [...]]" },
1718 { config_parse_service_type, "SERVICETYPE" },
1719 { config_parse_service_restart, "SERVICERESTART" },
1720 #ifdef HAVE_SYSV_COMPAT
1721 { config_parse_sysv_priority, "SYSVPRIORITY" },
1722 #else
1723 { config_parse_warn_compat, "NOTSUPPORTED" },
1724 #endif
1725 { config_parse_kill_mode, "KILLMODE" },
1726 { config_parse_kill_signal, "SIGNAL" },
1727 { config_parse_listen, "SOCKET [...]" },
1728 { config_parse_socket_bind, "SOCKETBIND" },
1729 { config_parse_bindtodevice, "NETWORKINTERFACE" },
1730 { config_parse_usec, "SECONDS" },
1731 { config_parse_path_strv, "PATH [...]" },
1732 { config_parse_mount_flags, "MOUNTFLAG [...]" },
1733 { config_parse_string_printf, "STRING" },
1734 { config_parse_timer, "TIMER" },
1735 { config_parse_timer_unit, "NAME" },
1736 { config_parse_path_spec, "PATH" },
1737 { config_parse_path_unit, "UNIT" },
1738 { config_parse_notify_access, "ACCESS" },
1739 { config_parse_ip_tos, "TOS" },
1740 { config_parse_condition_path, "CONDITION" },
1741 { config_parse_condition_string, "CONDITION" },
1742 { config_parse_condition_null, "CONDITION" },
1743 };
1744
1745 assert(f);
1746 assert(items);
1747
1748 for (i = items; i->lvalue; i++) {
1749 unsigned j;
1750 const char *rvalue = "OTHER";
1751
1752 if (!streq_ptr(i->section, prev_section)) {
1753 if (!not_first)
1754 not_first = true;
1755 else
1756 fputc('\n', f);
1757
1758 fprintf(f, "[%s]\n", i->section);
1759 prev_section = i->section;
1760 }
1761
1762 for (j = 0; j < ELEMENTSOF(table); j++)
1763 if (i->parse == table[j].callback) {
1764 rvalue = table[j].rvalue;
1765 break;
1766 }
1767
1768 fprintf(f, "%s=%s\n", i->lvalue, rvalue);
1769 }
1770 }
1771
1772 static int load_from_path(Unit *u, const char *path) {
1773
1774 static const char* const section_table[_UNIT_TYPE_MAX] = {
1775 [UNIT_SERVICE] = "Service",
1776 [UNIT_TIMER] = "Timer",
1777 [UNIT_SOCKET] = "Socket",
1778 [UNIT_TARGET] = "Target",
1779 [UNIT_DEVICE] = "Device",
1780 [UNIT_MOUNT] = "Mount",
1781 [UNIT_AUTOMOUNT] = "Automount",
1782 [UNIT_SNAPSHOT] = "Snapshot",
1783 [UNIT_SWAP] = "Swap",
1784 [UNIT_PATH] = "Path"
1785 };
1786
1787 #define EXEC_CONTEXT_CONFIG_ITEMS(context, section) \
1788 { "WorkingDirectory", config_parse_path, 0, &(context).working_directory, section }, \
1789 { "RootDirectory", config_parse_path, 0, &(context).root_directory, section }, \
1790 { "User", config_parse_string_printf, 0, &(context).user, section }, \
1791 { "Group", config_parse_string_printf, 0, &(context).group, section }, \
1792 { "SupplementaryGroups", config_parse_strv, 0, &(context).supplementary_groups, section }, \
1793 { "Nice", config_parse_nice, 0, &(context), section }, \
1794 { "OOMScoreAdjust", config_parse_oom_score_adjust,0, &(context), section }, \
1795 { "IOSchedulingClass", config_parse_io_class, 0, &(context), section }, \
1796 { "IOSchedulingPriority", config_parse_io_priority, 0, &(context), section }, \
1797 { "CPUSchedulingPolicy", config_parse_cpu_sched_policy,0, &(context), section }, \
1798 { "CPUSchedulingPriority", config_parse_cpu_sched_prio, 0, &(context), section }, \
1799 { "CPUSchedulingResetOnFork", config_parse_bool, 0, &(context).cpu_sched_reset_on_fork, section }, \
1800 { "CPUAffinity", config_parse_cpu_affinity, 0, &(context), section }, \
1801 { "UMask", config_parse_mode, 0, &(context).umask, section }, \
1802 { "Environment", config_parse_strv, 0, &(context).environment, section }, \
1803 { "EnvironmentFile", config_parse_env_file, 0, &(context).environment_files, section }, \
1804 { "StandardInput", config_parse_input, 0, &(context).std_input, section }, \
1805 { "StandardOutput", config_parse_output, 0, &(context).std_output, section }, \
1806 { "StandardError", config_parse_output, 0, &(context).std_error, section }, \
1807 { "TTYPath", config_parse_path, 0, &(context).tty_path, section }, \
1808 { "SyslogIdentifier", config_parse_string_printf, 0, &(context).syslog_identifier, section }, \
1809 { "SyslogFacility", config_parse_facility, 0, &(context).syslog_priority, section }, \
1810 { "SyslogLevel", config_parse_level, 0, &(context).syslog_priority, section }, \
1811 { "SyslogLevelPrefix", config_parse_bool, 0, &(context).syslog_level_prefix, section }, \
1812 { "Capabilities", config_parse_capabilities, 0, &(context), section }, \
1813 { "SecureBits", config_parse_secure_bits, 0, &(context), section }, \
1814 { "CapabilityBoundingSet", config_parse_bounding_set, 0, &(context), section }, \
1815 { "TimerSlackNSec", config_parse_timer_slack_nsec,0, &(context), section }, \
1816 { "LimitCPU", config_parse_limit, 0, &(context).rlimit[RLIMIT_CPU], section }, \
1817 { "LimitFSIZE", config_parse_limit, 0, &(context).rlimit[RLIMIT_FSIZE], section }, \
1818 { "LimitDATA", config_parse_limit, 0, &(context).rlimit[RLIMIT_DATA], section }, \
1819 { "LimitSTACK", config_parse_limit, 0, &(context).rlimit[RLIMIT_STACK], section }, \
1820 { "LimitCORE", config_parse_limit, 0, &(context).rlimit[RLIMIT_CORE], section }, \
1821 { "LimitRSS", config_parse_limit, 0, &(context).rlimit[RLIMIT_RSS], section }, \
1822 { "LimitNOFILE", config_parse_limit, 0, &(context).rlimit[RLIMIT_NOFILE], section }, \
1823 { "LimitAS", config_parse_limit, 0, &(context).rlimit[RLIMIT_AS], section }, \
1824 { "LimitNPROC", config_parse_limit, 0, &(context).rlimit[RLIMIT_NPROC], section }, \
1825 { "LimitMEMLOCK", config_parse_limit, 0, &(context).rlimit[RLIMIT_MEMLOCK], section }, \
1826 { "LimitLOCKS", config_parse_limit, 0, &(context).rlimit[RLIMIT_LOCKS], section }, \
1827 { "LimitSIGPENDING", config_parse_limit, 0, &(context).rlimit[RLIMIT_SIGPENDING], section }, \
1828 { "LimitMSGQUEUE", config_parse_limit, 0, &(context).rlimit[RLIMIT_MSGQUEUE], section }, \
1829 { "LimitNICE", config_parse_limit, 0, &(context).rlimit[RLIMIT_NICE], section }, \
1830 { "LimitRTPRIO", config_parse_limit, 0, &(context).rlimit[RLIMIT_RTPRIO], section }, \
1831 { "LimitRTTIME", config_parse_limit, 0, &(context).rlimit[RLIMIT_RTTIME], section }, \
1832 { "ControlGroup", config_parse_cgroup, 0, u, section }, \
1833 { "ReadWriteDirectories", config_parse_path_strv, 0, &(context).read_write_dirs, section }, \
1834 { "ReadOnlyDirectories", config_parse_path_strv, 0, &(context).read_only_dirs, section }, \
1835 { "InaccessibleDirectories",config_parse_path_strv, 0, &(context).inaccessible_dirs, section }, \
1836 { "PrivateTmp", config_parse_bool, 0, &(context).private_tmp, section }, \
1837 { "MountFlags", config_parse_mount_flags, 0, &(context), section }, \
1838 { "TCPWrapName", config_parse_string_printf, 0, &(context).tcpwrap_name, section }, \
1839 { "PAMName", config_parse_string_printf, 0, &(context).pam_name, section }, \
1840 { "KillMode", config_parse_kill_mode, 0, &(context).kill_mode, section }, \
1841 { "KillSignal", config_parse_kill_signal, 0, &(context).kill_signal, section }, \
1842 { "SendSIGKILL", config_parse_bool, 0, &(context).send_sigkill, section }, \
1843 { "UtmpIdentifier", config_parse_string_printf, 0, &(context).utmp_id, section }
1844
1845 const ConfigItem items[] = {
1846 { "Names", config_parse_names, 0, u, "Unit" },
1847 { "Description", config_parse_string_printf, 0, &u->meta.description, "Unit" },
1848 { "Requires", config_parse_deps, 0, UINT_TO_PTR(UNIT_REQUIRES), "Unit" },
1849 { "RequiresOverridable", config_parse_deps, 0, UINT_TO_PTR(UNIT_REQUIRES_OVERRIDABLE), "Unit" },
1850 { "Requisite", config_parse_deps, 0, UINT_TO_PTR(UNIT_REQUISITE), "Unit" },
1851 { "RequisiteOverridable", config_parse_deps, 0, UINT_TO_PTR(UNIT_REQUISITE_OVERRIDABLE), "Unit" },
1852 { "Wants", config_parse_deps, 0, UINT_TO_PTR(UNIT_WANTS), "Unit" },
1853 { "BindTo", config_parse_deps, 0, UINT_TO_PTR(UNIT_BIND_TO), "Unit" },
1854 { "Conflicts", config_parse_deps, 0, UINT_TO_PTR(UNIT_CONFLICTS), "Unit" },
1855 { "Before", config_parse_deps, 0, UINT_TO_PTR(UNIT_BEFORE), "Unit" },
1856 { "After", config_parse_deps, 0, UINT_TO_PTR(UNIT_AFTER), "Unit" },
1857 { "OnFailure", config_parse_deps, 0, UINT_TO_PTR(UNIT_ON_FAILURE), "Unit" },
1858 { "StopWhenUnneeded", config_parse_bool, 0, &u->meta.stop_when_unneeded, "Unit" },
1859 { "RefuseManualStart", config_parse_bool, 0, &u->meta.refuse_manual_start, "Unit" },
1860 { "RefuseManualStop", config_parse_bool, 0, &u->meta.refuse_manual_stop, "Unit" },
1861 { "AllowIsolate", config_parse_bool, 0, &u->meta.allow_isolate, "Unit" },
1862 { "DefaultDependencies", config_parse_bool, 0, &u->meta.default_dependencies, "Unit" },
1863 { "OnFailureIsolate", config_parse_bool, 0, &u->meta.on_failure_isolate, "Unit" },
1864 { "JobTimeoutSec", config_parse_usec, 0, &u->meta.job_timeout, "Unit" },
1865 { "ConditionPathExists", config_parse_condition_path, CONDITION_PATH_EXISTS, u, "Unit" },
1866 { "ConditionPathIsDirectory", config_parse_condition_path, CONDITION_PATH_IS_DIRECTORY, u, "Unit" },
1867 { "ConditionDirectoryNotEmpty", config_parse_condition_path, CONDITION_DIRECTORY_NOT_EMPTY, u, "Unit" },
1868 { "ConditionKernelCommandLine", config_parse_condition_string, CONDITION_KERNEL_COMMAND_LINE, u, "Unit" },
1869 { "ConditionVirtualization", config_parse_condition_string, CONDITION_VIRTUALIZATION, u, "Unit" },
1870 { "ConditionSecurity", config_parse_condition_string, CONDITION_SECURITY, u, "Unit" },
1871 { "ConditionNull", config_parse_condition_null, 0, u, "Unit" },
1872
1873 { "PIDFile", config_parse_path, 0, &u->service.pid_file, "Service" },
1874 { "ExecStartPre", config_parse_exec, 0, u->service.exec_command+SERVICE_EXEC_START_PRE, "Service" },
1875 { "ExecStart", config_parse_exec, 0, u->service.exec_command+SERVICE_EXEC_START, "Service" },
1876 { "ExecStartPost", config_parse_exec, 0, u->service.exec_command+SERVICE_EXEC_START_POST, "Service" },
1877 { "ExecReload", config_parse_exec, 0, u->service.exec_command+SERVICE_EXEC_RELOAD, "Service" },
1878 { "ExecStop", config_parse_exec, 0, u->service.exec_command+SERVICE_EXEC_STOP, "Service" },
1879 { "ExecStopPost", config_parse_exec, 0, u->service.exec_command+SERVICE_EXEC_STOP_POST, "Service" },
1880 { "RestartSec", config_parse_usec, 0, &u->service.restart_usec, "Service" },
1881 { "TimeoutSec", config_parse_usec, 0, &u->service.timeout_usec, "Service" },
1882 { "Type", config_parse_service_type, 0, &u->service.type, "Service" },
1883 { "Restart", config_parse_service_restart, 0, &u->service.restart, "Service" },
1884 { "PermissionsStartOnly", config_parse_bool, 0, &u->service.permissions_start_only, "Service" },
1885 { "RootDirectoryStartOnly", config_parse_bool, 0, &u->service.root_directory_start_only, "Service" },
1886 { "RemainAfterExit", config_parse_bool, 0, &u->service.remain_after_exit, "Service" },
1887 { "GuessMainPID", config_parse_bool, 0, &u->service.guess_main_pid, "Service" },
1888 #ifdef HAVE_SYSV_COMPAT
1889 { "SysVStartPriority", config_parse_sysv_priority, 0, &u->service.sysv_start_priority, "Service" },
1890 #else
1891 { "SysVStartPriority", config_parse_warn_compat, 0, NULL, "Service" },
1892 #endif
1893 { "NonBlocking", config_parse_bool, 0, &u->service.exec_context.non_blocking, "Service" },
1894 { "BusName", config_parse_string_printf, 0, &u->service.bus_name, "Service" },
1895 { "NotifyAccess", config_parse_notify_access, 0, &u->service.notify_access, "Service" },
1896 { "Sockets", config_parse_service_sockets, 0, &u->service, "Service" },
1897 { "FsckPassNo", config_parse_fsck_passno, 0, &u->service.fsck_passno, "Service" },
1898 EXEC_CONTEXT_CONFIG_ITEMS(u->service.exec_context, "Service"),
1899
1900 { "ListenStream", config_parse_listen, 0, &u->socket, "Socket" },
1901 { "ListenDatagram", config_parse_listen, 0, &u->socket, "Socket" },
1902 { "ListenSequentialPacket", config_parse_listen, 0, &u->socket, "Socket" },
1903 { "ListenFIFO", config_parse_listen, 0, &u->socket, "Socket" },
1904 { "ListenNetlink", config_parse_listen, 0, &u->socket, "Socket" },
1905 { "BindIPv6Only", config_parse_socket_bind, 0, &u->socket, "Socket" },
1906 { "Backlog", config_parse_unsigned, 0, &u->socket.backlog, "Socket" },
1907 { "BindToDevice", config_parse_bindtodevice, 0, &u->socket, "Socket" },
1908 { "ExecStartPre", config_parse_exec, 0, u->socket.exec_command+SOCKET_EXEC_START_PRE, "Socket" },
1909 { "ExecStartPost", config_parse_exec, 0, u->socket.exec_command+SOCKET_EXEC_START_POST, "Socket" },
1910 { "ExecStopPre", config_parse_exec, 0, u->socket.exec_command+SOCKET_EXEC_STOP_PRE, "Socket" },
1911 { "ExecStopPost", config_parse_exec, 0, u->socket.exec_command+SOCKET_EXEC_STOP_POST, "Socket" },
1912 { "TimeoutSec", config_parse_usec, 0, &u->socket.timeout_usec, "Socket" },
1913 { "DirectoryMode", config_parse_mode, 0, &u->socket.directory_mode, "Socket" },
1914 { "SocketMode", config_parse_mode, 0, &u->socket.socket_mode, "Socket" },
1915 { "Accept", config_parse_bool, 0, &u->socket.accept, "Socket" },
1916 { "MaxConnections", config_parse_unsigned, 0, &u->socket.max_connections, "Socket" },
1917 { "KeepAlive", config_parse_bool, 0, &u->socket.keep_alive, "Socket" },
1918 { "Priority", config_parse_int, 0, &u->socket.priority, "Socket" },
1919 { "ReceiveBuffer", config_parse_size, 0, &u->socket.receive_buffer, "Socket" },
1920 { "SendBuffer", config_parse_size, 0, &u->socket.send_buffer, "Socket" },
1921 { "IPTOS", config_parse_ip_tos, 0, &u->socket.ip_tos, "Socket" },
1922 { "IPTTL", config_parse_int, 0, &u->socket.ip_ttl, "Socket" },
1923 { "Mark", config_parse_int, 0, &u->socket.mark, "Socket" },
1924 { "PipeSize", config_parse_size, 0, &u->socket.pipe_size, "Socket" },
1925 { "FreeBind", config_parse_bool, 0, &u->socket.free_bind, "Socket" },
1926 { "TCPCongestion", config_parse_string, 0, &u->socket.tcp_congestion, "Socket" },
1927 { "Service", config_parse_socket_service, 0, &u->socket, "Socket" },
1928 EXEC_CONTEXT_CONFIG_ITEMS(u->socket.exec_context, "Socket"),
1929
1930 { "What", config_parse_string, 0, &u->mount.parameters_fragment.what, "Mount" },
1931 { "Where", config_parse_path, 0, &u->mount.where, "Mount" },
1932 { "Options", config_parse_string, 0, &u->mount.parameters_fragment.options, "Mount" },
1933 { "Type", config_parse_string, 0, &u->mount.parameters_fragment.fstype, "Mount" },
1934 { "TimeoutSec", config_parse_usec, 0, &u->mount.timeout_usec, "Mount" },
1935 { "DirectoryMode", config_parse_mode, 0, &u->mount.directory_mode, "Mount" },
1936 EXEC_CONTEXT_CONFIG_ITEMS(u->mount.exec_context, "Mount"),
1937
1938 { "Where", config_parse_path, 0, &u->automount.where, "Automount" },
1939 { "DirectoryMode", config_parse_mode, 0, &u->automount.directory_mode, "Automount" },
1940
1941 { "What", config_parse_path, 0, &u->swap.parameters_fragment.what, "Swap" },
1942 { "Priority", config_parse_int, 0, &u->swap.parameters_fragment.priority, "Swap" },
1943 { "TimeoutSec", config_parse_usec, 0, &u->swap.timeout_usec, "Swap" },
1944 EXEC_CONTEXT_CONFIG_ITEMS(u->swap.exec_context, "Swap"),
1945
1946 { "OnActiveSec", config_parse_timer, 0, &u->timer, "Timer" },
1947 { "OnBootSec", config_parse_timer, 0, &u->timer, "Timer" },
1948 { "OnStartupSec", config_parse_timer, 0, &u->timer, "Timer" },
1949 { "OnUnitActiveSec", config_parse_timer, 0, &u->timer, "Timer" },
1950 { "OnUnitInactiveSec", config_parse_timer, 0, &u->timer, "Timer" },
1951 { "Unit", config_parse_timer_unit, 0, &u->timer, "Timer" },
1952
1953 { "PathExists", config_parse_path_spec, 0, &u->path, "Path" },
1954 { "PathChanged", config_parse_path_spec, 0, &u->path, "Path" },
1955 { "DirectoryNotEmpty", config_parse_path_spec, 0, &u->path, "Path" },
1956 { "Unit", config_parse_path_unit, 0, &u->path, "Path" },
1957 { "MakeDirectory", config_parse_bool, 0, &u->path.make_directory, "Path" },
1958 { "DirectoryMode", config_parse_mode, 0, &u->path.directory_mode, "Path" },
1959
1960 /* The [Install] section is ignored here. */
1961 { "Alias", NULL, 0, NULL, "Install" },
1962 { "WantedBy", NULL, 0, NULL, "Install" },
1963 { "Also", NULL, 0, NULL, "Install" },
1964
1965 { NULL, NULL, 0, NULL, NULL }
1966 };
1967
1968 #undef EXEC_CONTEXT_CONFIG_ITEMS
1969
1970 const char *sections[4];
1971 int r;
1972 Set *symlink_names;
1973 FILE *f = NULL;
1974 char *filename = NULL, *id = NULL;
1975 Unit *merged;
1976 struct stat st;
1977
1978 if (!u) {
1979 /* Dirty dirty hack. */
1980 dump_items((FILE*) path, items);
1981 return 0;
1982 }
1983
1984 assert(u);
1985 assert(path);
1986
1987 sections[0] = "Unit";
1988 sections[1] = section_table[u->meta.type];
1989 sections[2] = "Install";
1990 sections[3] = NULL;
1991
1992 if (!(symlink_names = set_new(string_hash_func, string_compare_func)))
1993 return -ENOMEM;
1994
1995 if (path_is_absolute(path)) {
1996
1997 if (!(filename = strdup(path))) {
1998 r = -ENOMEM;
1999 goto finish;
2000 }
2001
2002 if ((r = open_follow(&filename, &f, symlink_names, &id)) < 0) {
2003 free(filename);
2004 filename = NULL;
2005
2006 if (r != -ENOENT)
2007 goto finish;
2008 }
2009
2010 } else {
2011 char **p;
2012
2013 STRV_FOREACH(p, u->meta.manager->lookup_paths.unit_path) {
2014
2015 /* Instead of opening the path right away, we manually
2016 * follow all symlinks and add their name to our unit
2017 * name set while doing so */
2018 if (!(filename = path_make_absolute(path, *p))) {
2019 r = -ENOMEM;
2020 goto finish;
2021 }
2022
2023 if (u->meta.manager->unit_path_cache &&
2024 !set_get(u->meta.manager->unit_path_cache, filename))
2025 r = -ENOENT;
2026 else
2027 r = open_follow(&filename, &f, symlink_names, &id);
2028
2029 if (r < 0) {
2030 char *sn;
2031
2032 free(filename);
2033 filename = NULL;
2034
2035 if (r != -ENOENT)
2036 goto finish;
2037
2038 /* Empty the symlink names for the next run */
2039 while ((sn = set_steal_first(symlink_names)))
2040 free(sn);
2041
2042 continue;
2043 }
2044
2045 break;
2046 }
2047 }
2048
2049 if (!filename) {
2050 /* Hmm, no suitable file found? */
2051 r = 0;
2052 goto finish;
2053 }
2054
2055 merged = u;
2056 if ((r = merge_by_names(&merged, symlink_names, id)) < 0)
2057 goto finish;
2058
2059 if (merged != u) {
2060 u->meta.load_state = UNIT_MERGED;
2061 r = 0;
2062 goto finish;
2063 }
2064
2065 zero(st);
2066 if (fstat(fileno(f), &st) < 0) {
2067 r = -errno;
2068 goto finish;
2069 }
2070
2071 if (null_or_empty(&st))
2072 u->meta.load_state = UNIT_MASKED;
2073 else {
2074 /* Now, parse the file contents */
2075 if ((r = config_parse(filename, f, sections, items, false, u)) < 0)
2076 goto finish;
2077
2078 u->meta.load_state = UNIT_LOADED;
2079 }
2080
2081 free(u->meta.fragment_path);
2082 u->meta.fragment_path = filename;
2083 filename = NULL;
2084
2085 u->meta.fragment_mtime = timespec_load(&st.st_mtim);
2086
2087 r = 0;
2088
2089 finish:
2090 set_free_free(symlink_names);
2091 free(filename);
2092
2093 if (f)
2094 fclose(f);
2095
2096 return r;
2097 }
2098
2099 int unit_load_fragment(Unit *u) {
2100 int r;
2101 Iterator i;
2102 const char *t;
2103
2104 assert(u);
2105 assert(u->meta.load_state == UNIT_STUB);
2106 assert(u->meta.id);
2107
2108 /* First, try to find the unit under its id. We always look
2109 * for unit files in the default directories, to make it easy
2110 * to override things by placing things in /etc/systemd/system */
2111 if ((r = load_from_path(u, u->meta.id)) < 0)
2112 return r;
2113
2114 /* Try to find an alias we can load this with */
2115 if (u->meta.load_state == UNIT_STUB)
2116 SET_FOREACH(t, u->meta.names, i) {
2117
2118 if (t == u->meta.id)
2119 continue;
2120
2121 if ((r = load_from_path(u, t)) < 0)
2122 return r;
2123
2124 if (u->meta.load_state != UNIT_STUB)
2125 break;
2126 }
2127
2128 /* And now, try looking for it under the suggested (originally linked) path */
2129 if (u->meta.load_state == UNIT_STUB && u->meta.fragment_path) {
2130
2131 if ((r = load_from_path(u, u->meta.fragment_path)) < 0)
2132 return r;
2133
2134 if (u->meta.load_state == UNIT_STUB) {
2135 /* Hmm, this didn't work? Then let's get rid
2136 * of the fragment path stored for us, so that
2137 * we don't point to an invalid location. */
2138 free(u->meta.fragment_path);
2139 u->meta.fragment_path = NULL;
2140 }
2141 }
2142
2143 /* Look for a template */
2144 if (u->meta.load_state == UNIT_STUB && u->meta.instance) {
2145 char *k;
2146
2147 if (!(k = unit_name_template(u->meta.id)))
2148 return -ENOMEM;
2149
2150 r = load_from_path(u, k);
2151 free(k);
2152
2153 if (r < 0)
2154 return r;
2155
2156 if (u->meta.load_state == UNIT_STUB)
2157 SET_FOREACH(t, u->meta.names, i) {
2158
2159 if (t == u->meta.id)
2160 continue;
2161
2162 if (!(k = unit_name_template(t)))
2163 return -ENOMEM;
2164
2165 r = load_from_path(u, k);
2166 free(k);
2167
2168 if (r < 0)
2169 return r;
2170
2171 if (u->meta.load_state != UNIT_STUB)
2172 break;
2173 }
2174 }
2175
2176 return 0;
2177 }
2178
2179 void unit_dump_config_items(FILE *f) {
2180 /* OK, this wins a prize for extreme ugliness. */
2181
2182 load_from_path(NULL, (const void*) f);
2183 }
Unnamed repository; edit this file 'description' to name the repository.