]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/load-fragment.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use enums to make it obvious what boolean params mean
[thirdparty/systemd.git] / src / core / 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 Copyright 2012 Holger Hans Peter Freyther
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <linux/oom.h>
24 #include <assert.h>
25 #include <errno.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <sched.h>
30 #include <sys/prctl.h>
31 #include <sys/mount.h>
32 #include <linux/fs.h>
33 #include <sys/stat.h>
34 #include <sys/time.h>
35 #include <sys/resource.h>
36
37 #include "sd-messages.h"
38 #include "unit.h"
39 #include "strv.h"
40 #include "conf-parser.h"
41 #include "load-fragment.h"
42 #include "log.h"
43 #include "ioprio.h"
44 #include "securebits.h"
45 #include "missing.h"
46 #include "unit-name.h"
47 #include "unit-printf.h"
48 #include "utf8.h"
49 #include "path-util.h"
50 #include "syscall-list.h"
51 #include "env-util.h"
52 #include "cgroup.h"
53 #include "bus-util.h"
54 #include "bus-error.h"
55
56 #ifndef HAVE_SYSV_COMPAT
57 int config_parse_warn_compat(const char *unit,
58 const char *filename,
59 unsigned line,
60 const char *section,
61 unsigned section_line,
62 const char *lvalue,
63 int ltype,
64 const char *rvalue,
65 void *data,
66 void *userdata) {
67
68 log_syntax(unit, LOG_DEBUG, filename, line, EINVAL,
69 "Support for option %s= has been disabled at compile time and is ignored",
70 lvalue);
71 return 0;
72 }
73 #endif
74
75 int config_parse_unit_deps(const char* unit,
76 const char *filename,
77 unsigned line,
78 const char *section,
79 unsigned section_line,
80 const char *lvalue,
81 int ltype,
82 const char *rvalue,
83 void *data,
84 void *userdata) {
85
86 UnitDependency d = ltype;
87 Unit *u = userdata;
88 char *w;
89 size_t l;
90 char *state;
91
92 assert(filename);
93 assert(lvalue);
94 assert(rvalue);
95
96 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
97 _cleanup_free_ char *t = NULL, *k = NULL;
98 int r;
99
100 t = strndup(w, l);
101 if (!t)
102 return log_oom();
103
104 r = unit_name_printf(u, t, &k);
105 if (r < 0) {
106 log_syntax(unit, LOG_ERR, filename, line, -r,
107 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
108 continue;
109 }
110
111 r = unit_add_dependency_by_name(u, d, k, NULL, true);
112 if (r < 0)
113 log_syntax(unit, LOG_ERR, filename, line, -r,
114 "Failed to add dependency on %s, ignoring: %s", k, strerror(-r));
115 }
116
117 return 0;
118 }
119
120 int config_parse_unit_string_printf(const char *unit,
121 const char *filename,
122 unsigned line,
123 const char *section,
124 unsigned section_line,
125 const char *lvalue,
126 int ltype,
127 const char *rvalue,
128 void *data,
129 void *userdata) {
130
131 Unit *u = userdata;
132 _cleanup_free_ char *k = NULL;
133 int r;
134
135 assert(filename);
136 assert(lvalue);
137 assert(rvalue);
138 assert(u);
139
140 r = unit_full_printf(u, rvalue, &k);
141 if (r < 0)
142 log_syntax(unit, LOG_ERR, filename, line, -r,
143 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
144
145 return config_parse_string(unit, filename, line, section, section_line, lvalue, ltype,
146 k ? k : rvalue, data, userdata);
147 }
148
149 int config_parse_unit_strv_printf(const char *unit,
150 const char *filename,
151 unsigned line,
152 const char *section,
153 unsigned section_line,
154 const char *lvalue,
155 int ltype,
156 const char *rvalue,
157 void *data,
158 void *userdata) {
159
160 Unit *u = userdata;
161 _cleanup_free_ char *k = NULL;
162 int r;
163
164 assert(filename);
165 assert(lvalue);
166 assert(rvalue);
167 assert(u);
168
169 r = unit_full_printf(u, rvalue, &k);
170 if (r < 0)
171 log_syntax(unit, LOG_ERR, filename, line, -r,
172 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
173
174 return config_parse_strv(unit, filename, line, section, section_line, lvalue, ltype,
175 k ? k : rvalue, data, userdata);
176 }
177
178 int config_parse_unit_path_printf(const char *unit,
179 const char *filename,
180 unsigned line,
181 const char *section,
182 unsigned section_line,
183 const char *lvalue,
184 int ltype,
185 const char *rvalue,
186 void *data,
187 void *userdata) {
188
189 Unit *u = userdata;
190 _cleanup_free_ char *k = NULL;
191 int r;
192
193 assert(filename);
194 assert(lvalue);
195 assert(rvalue);
196 assert(u);
197
198 r = unit_full_printf(u, rvalue, &k);
199 if (r < 0)
200 log_syntax(unit, LOG_ERR, filename, line, -r,
201 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
202
203 return config_parse_path(unit, filename, line, section, section_line, lvalue, ltype,
204 k ? k : rvalue, data, userdata);
205 }
206
207 int config_parse_socket_listen(const char *unit,
208 const char *filename,
209 unsigned line,
210 const char *section,
211 unsigned section_line,
212 const char *lvalue,
213 int ltype,
214 const char *rvalue,
215 void *data,
216 void *userdata) {
217
218 SocketPort *p, *tail;
219 Socket *s;
220 int r;
221
222 assert(filename);
223 assert(lvalue);
224 assert(rvalue);
225 assert(data);
226
227 s = SOCKET(data);
228
229 if (isempty(rvalue)) {
230 /* An empty assignment removes all ports */
231 socket_free_ports(s);
232 return 0;
233 }
234
235 p = new0(SocketPort, 1);
236 if (!p)
237 return log_oom();
238
239 if (ltype != SOCKET_SOCKET) {
240
241 p->type = ltype;
242 r = unit_full_printf(UNIT(s), rvalue, &p->path);
243 if (r < 0) {
244 p->path = strdup(rvalue);
245 if (!p->path) {
246 free(p);
247 return log_oom();
248 } else
249 log_syntax(unit, LOG_ERR, filename, line, -r,
250 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
251 }
252
253 path_kill_slashes(p->path);
254
255 } else if (streq(lvalue, "ListenNetlink")) {
256 _cleanup_free_ char *k = NULL;
257
258 p->type = SOCKET_SOCKET;
259 r = unit_full_printf(UNIT(s), rvalue, &k);
260 if (r < 0)
261 log_syntax(unit, LOG_ERR, filename, line, -r,
262 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
263
264 r = socket_address_parse_netlink(&p->address, k ? k : rvalue);
265 if (r < 0) {
266 log_syntax(unit, LOG_ERR, filename, line, -r,
267 "Failed to parse address value, ignoring: %s", rvalue);
268 free(p);
269 return 0;
270 }
271
272 } else {
273 _cleanup_free_ char *k = NULL;
274
275 p->type = SOCKET_SOCKET;
276 r = unit_full_printf(UNIT(s), rvalue, &k);
277 if (r < 0)
278 log_syntax(unit, LOG_ERR, filename, line, -r,
279 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
280
281 r = socket_address_parse(&p->address, k ? k : rvalue);
282 if (r < 0) {
283 log_syntax(unit, LOG_ERR, filename, line, -r,
284 "Failed to parse address value, ignoring: %s", rvalue);
285 free(p);
286 return 0;
287 }
288
289 if (streq(lvalue, "ListenStream"))
290 p->address.type = SOCK_STREAM;
291 else if (streq(lvalue, "ListenDatagram"))
292 p->address.type = SOCK_DGRAM;
293 else {
294 assert(streq(lvalue, "ListenSequentialPacket"));
295 p->address.type = SOCK_SEQPACKET;
296 }
297
298 if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {
299 log_syntax(unit, LOG_ERR, filename, line, ENOTSUP,
300 "Address family not supported, ignoring: %s", rvalue);
301 free(p);
302 return 0;
303 }
304 }
305
306 p->fd = -1;
307 p->socket = s;
308
309 if (s->ports) {
310 LIST_FIND_TAIL(port, s->ports, tail);
311 LIST_INSERT_AFTER(port, s->ports, tail, p);
312 } else
313 LIST_PREPEND(port, s->ports, p);
314
315 return 0;
316 }
317
318 int config_parse_socket_bind(const char *unit,
319 const char *filename,
320 unsigned line,
321 const char *section,
322 unsigned section_line,
323 const char *lvalue,
324 int ltype,
325 const char *rvalue,
326 void *data,
327 void *userdata) {
328
329 Socket *s;
330 SocketAddressBindIPv6Only b;
331
332 assert(filename);
333 assert(lvalue);
334 assert(rvalue);
335 assert(data);
336
337 s = SOCKET(data);
338
339 b = socket_address_bind_ipv6_only_from_string(rvalue);
340 if (b < 0) {
341 int r;
342
343 r = parse_boolean(rvalue);
344 if (r < 0) {
345 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
346 "Failed to parse bind IPv6 only value, ignoring: %s", rvalue);
347 return 0;
348 }
349
350 s->bind_ipv6_only = r ? SOCKET_ADDRESS_IPV6_ONLY : SOCKET_ADDRESS_BOTH;
351 } else
352 s->bind_ipv6_only = b;
353
354 return 0;
355 }
356
357 int config_parse_exec_nice(const char *unit,
358 const char *filename,
359 unsigned line,
360 const char *section,
361 unsigned section_line,
362 const char *lvalue,
363 int ltype,
364 const char *rvalue,
365 void *data,
366 void *userdata) {
367
368 ExecContext *c = data;
369 int priority, r;
370
371 assert(filename);
372 assert(lvalue);
373 assert(rvalue);
374 assert(data);
375
376 r = safe_atoi(rvalue, &priority);
377 if (r < 0) {
378 log_syntax(unit, LOG_ERR, filename, line, -r,
379 "Failed to parse nice priority, ignoring: %s. ", rvalue);
380 return 0;
381 }
382
383 if (priority < PRIO_MIN || priority >= PRIO_MAX) {
384 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
385 "Nice priority out of range, ignoring: %s", rvalue);
386 return 0;
387 }
388
389 c->nice = priority;
390 c->nice_set = true;
391
392 return 0;
393 }
394
395 int config_parse_exec_oom_score_adjust(const char* unit,
396 const char *filename,
397 unsigned line,
398 const char *section,
399 unsigned section_line,
400 const char *lvalue,
401 int ltype,
402 const char *rvalue,
403 void *data,
404 void *userdata) {
405
406 ExecContext *c = data;
407 int oa, r;
408
409 assert(filename);
410 assert(lvalue);
411 assert(rvalue);
412 assert(data);
413
414 r = safe_atoi(rvalue, &oa);
415 if (r < 0) {
416 log_syntax(unit, LOG_ERR, filename, line, -r,
417 "Failed to parse the OOM score adjust value, ignoring: %s", rvalue);
418 return 0;
419 }
420
421 if (oa < OOM_SCORE_ADJ_MIN || oa > OOM_SCORE_ADJ_MAX) {
422 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
423 "OOM score adjust value out of range, ignoring: %s", rvalue);
424 return 0;
425 }
426
427 c->oom_score_adjust = oa;
428 c->oom_score_adjust_set = true;
429
430 return 0;
431 }
432
433 int config_parse_exec(const char *unit,
434 const char *filename,
435 unsigned line,
436 const char *section,
437 unsigned section_line,
438 const char *lvalue,
439 int ltype,
440 const char *rvalue,
441 void *data,
442 void *userdata) {
443
444 ExecCommand **e = data, *nce;
445 char *path, **n;
446 unsigned k;
447 int r;
448
449 assert(filename);
450 assert(lvalue);
451 assert(rvalue);
452 assert(e);
453
454 e += ltype;
455
456 if (isempty(rvalue)) {
457 /* An empty assignment resets the list */
458 exec_command_free_list(*e);
459 *e = NULL;
460 return 0;
461 }
462
463 /* We accept an absolute path as first argument, or
464 * alternatively an absolute prefixed with @ to allow
465 * overriding of argv[0]. */
466 for (;;) {
467 int i;
468 char *w;
469 size_t l;
470 char *state;
471 bool honour_argv0 = false, ignore = false;
472
473 path = NULL;
474 nce = NULL;
475 n = NULL;
476
477 rvalue += strspn(rvalue, WHITESPACE);
478
479 if (rvalue[0] == 0)
480 break;
481
482 for (i = 0; i < 2; i++) {
483 if (rvalue[0] == '-' && !ignore) {
484 ignore = true;
485 rvalue ++;
486 }
487
488 if (rvalue[0] == '@' && !honour_argv0) {
489 honour_argv0 = true;
490 rvalue ++;
491 }
492 }
493
494 if (*rvalue != '/') {
495 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
496 "Executable path is not absolute, ignoring: %s", rvalue);
497 return 0;
498 }
499
500 k = 0;
501 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
502 if (strneq(w, ";", MAX(l, 1U)))
503 break;
504
505 k++;
506 }
507
508 n = new(char*, k + !honour_argv0);
509 if (!n)
510 return log_oom();
511
512 k = 0;
513 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
514 if (strneq(w, ";", MAX(l, 1U)))
515 break;
516 else if (strneq(w, "\\;", MAX(l, 1U)))
517 w ++;
518
519 if (honour_argv0 && w == rvalue) {
520 assert(!path);
521
522 path = strndup(w, l);
523 if (!path) {
524 r = log_oom();
525 goto fail;
526 }
527
528 if (!utf8_is_valid(path)) {
529 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
530 "Path is not UTF-8 clean, ignoring assignment: %s",
531 rvalue);
532 r = 0;
533 goto fail;
534 }
535
536 } else {
537 char *c;
538
539 c = n[k++] = cunescape_length(w, l);
540 if (!c) {
541 r = log_oom();
542 goto fail;
543 }
544
545 if (!utf8_is_valid(c)) {
546 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
547 "Path is not UTF-8 clean, ignoring assignment: %s",
548 rvalue);
549 r = 0;
550 goto fail;
551 }
552 }
553 }
554
555 n[k] = NULL;
556
557 if (!n[0]) {
558 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
559 "Invalid command line, ignoring: %s", rvalue);
560 r = 0;
561 goto fail;
562 }
563
564 if (!path) {
565 path = strdup(n[0]);
566 if (!path) {
567 r = log_oom();
568 goto fail;
569 }
570 }
571
572 assert(path_is_absolute(path));
573
574 nce = new0(ExecCommand, 1);
575 if (!nce) {
576 r = log_oom();
577 goto fail;
578 }
579
580 nce->argv = n;
581 nce->path = path;
582 nce->ignore = ignore;
583
584 path_kill_slashes(nce->path);
585
586 exec_command_append_list(e, nce);
587
588 rvalue = state;
589 }
590
591 return 0;
592
593 fail:
594 n[k] = NULL;
595 strv_free(n);
596 free(path);
597 free(nce);
598
599 return r;
600 }
601
602 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type");
603 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier");
604
605 int config_parse_socket_bindtodevice(const char* unit,
606 const char *filename,
607 unsigned line,
608 const char *section,
609 unsigned section_line,
610 const char *lvalue,
611 int ltype,
612 const char *rvalue,
613 void *data,
614 void *userdata) {
615
616 Socket *s = data;
617 char *n;
618
619 assert(filename);
620 assert(lvalue);
621 assert(rvalue);
622 assert(data);
623
624 if (rvalue[0] && !streq(rvalue, "*")) {
625 n = strdup(rvalue);
626 if (!n)
627 return log_oom();
628 } else
629 n = NULL;
630
631 free(s->bind_to_device);
632 s->bind_to_device = n;
633
634 return 0;
635 }
636
637 DEFINE_CONFIG_PARSE_ENUM(config_parse_output, exec_output, ExecOutput, "Failed to parse output specifier");
638 DEFINE_CONFIG_PARSE_ENUM(config_parse_input, exec_input, ExecInput, "Failed to parse input specifier");
639
640 int config_parse_exec_io_class(const char *unit,
641 const char *filename,
642 unsigned line,
643 const char *section,
644 unsigned section_line,
645 const char *lvalue,
646 int ltype,
647 const char *rvalue,
648 void *data,
649 void *userdata) {
650
651 ExecContext *c = data;
652 int x;
653
654 assert(filename);
655 assert(lvalue);
656 assert(rvalue);
657 assert(data);
658
659 x = ioprio_class_from_string(rvalue);
660 if (x < 0) {
661 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
662 "Failed to parse IO scheduling class, ignoring: %s", rvalue);
663 return 0;
664 }
665
666 c->ioprio = IOPRIO_PRIO_VALUE(x, IOPRIO_PRIO_DATA(c->ioprio));
667 c->ioprio_set = true;
668
669 return 0;
670 }
671
672 int config_parse_exec_io_priority(const char *unit,
673 const char *filename,
674 unsigned line,
675 const char *section,
676 unsigned section_line,
677 const char *lvalue,
678 int ltype,
679 const char *rvalue,
680 void *data,
681 void *userdata) {
682
683 ExecContext *c = data;
684 int i, r;
685
686 assert(filename);
687 assert(lvalue);
688 assert(rvalue);
689 assert(data);
690
691 r = safe_atoi(rvalue, &i);
692 if (r < 0 || i < 0 || i >= IOPRIO_BE_NR) {
693 log_syntax(unit, LOG_ERR, filename, line, -r,
694 "Failed to parse IO priority, ignoring: %s", rvalue);
695 return 0;
696 }
697
698 c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_PRIO_CLASS(c->ioprio), i);
699 c->ioprio_set = true;
700
701 return 0;
702 }
703
704 int config_parse_exec_cpu_sched_policy(const char *unit,
705 const char *filename,
706 unsigned line,
707 const char *section,
708 unsigned section_line,
709 const char *lvalue,
710 int ltype,
711 const char *rvalue,
712 void *data,
713 void *userdata) {
714
715
716 ExecContext *c = data;
717 int x;
718
719 assert(filename);
720 assert(lvalue);
721 assert(rvalue);
722 assert(data);
723
724 x = sched_policy_from_string(rvalue);
725 if (x < 0) {
726 log_syntax(unit, LOG_ERR, filename, line, -x,
727 "Failed to parse CPU scheduling policy, ignoring: %s", rvalue);
728 return 0;
729 }
730
731 c->cpu_sched_policy = x;
732 /* Moving to or from real-time policy? We need to adjust the priority */
733 c->cpu_sched_priority = CLAMP(c->cpu_sched_priority, sched_get_priority_min(x), sched_get_priority_max(x));
734 c->cpu_sched_set = true;
735
736 return 0;
737 }
738
739 int config_parse_exec_cpu_sched_prio(const char *unit,
740 const char *filename,
741 unsigned line,
742 const char *section,
743 unsigned section_line,
744 const char *lvalue,
745 int ltype,
746 const char *rvalue,
747 void *data,
748 void *userdata) {
749
750 ExecContext *c = data;
751 int i, min, max, r;
752
753 assert(filename);
754 assert(lvalue);
755 assert(rvalue);
756 assert(data);
757
758 r = safe_atoi(rvalue, &i);
759 if (r < 0) {
760 log_syntax(unit, LOG_ERR, filename, line, -r,
761 "Failed to parse CPU scheduling policy, ignoring: %s", rvalue);
762 return 0;
763 }
764
765 /* On Linux RR/FIFO range from 1 to 99 and OTHER/BATCH may only be 0 */
766 min = sched_get_priority_min(c->cpu_sched_policy);
767 max = sched_get_priority_max(c->cpu_sched_policy);
768
769 if (i < min || i > max) {
770 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
771 "CPU scheduling priority is out of range, ignoring: %s", rvalue);
772 return 0;
773 }
774
775 c->cpu_sched_priority = i;
776 c->cpu_sched_set = true;
777
778 return 0;
779 }
780
781 int config_parse_exec_cpu_affinity(const char *unit,
782 const char *filename,
783 unsigned line,
784 const char *section,
785 unsigned section_line,
786 const char *lvalue,
787 int ltype,
788 const char *rvalue,
789 void *data,
790 void *userdata) {
791
792 ExecContext *c = data;
793 char *w;
794 size_t l;
795 char *state;
796
797 assert(filename);
798 assert(lvalue);
799 assert(rvalue);
800 assert(data);
801
802 if (isempty(rvalue)) {
803 /* An empty assignment resets the CPU list */
804 if (c->cpuset)
805 CPU_FREE(c->cpuset);
806 c->cpuset = NULL;
807 return 0;
808 }
809
810 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
811 _cleanup_free_ char *t = NULL;
812 int r;
813 unsigned cpu;
814
815 t = strndup(w, l);
816 if (!t)
817 return log_oom();
818
819 r = safe_atou(t, &cpu);
820
821 if (!c->cpuset) {
822 c->cpuset = cpu_set_malloc(&c->cpuset_ncpus);
823 if (!c->cpuset)
824 return log_oom();
825 }
826
827 if (r < 0 || cpu >= c->cpuset_ncpus) {
828 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
829 "Failed to parse CPU affinity '%s', ignoring: %s", t, rvalue);
830 return 0;
831 }
832
833 CPU_SET_S(cpu, CPU_ALLOC_SIZE(c->cpuset_ncpus), c->cpuset);
834 }
835
836 return 0;
837 }
838
839 int config_parse_exec_capabilities(const char *unit,
840 const char *filename,
841 unsigned line,
842 const char *section,
843 unsigned section_line,
844 const char *lvalue,
845 int ltype,
846 const char *rvalue,
847 void *data,
848 void *userdata) {
849
850 ExecContext *c = data;
851 cap_t cap;
852
853 assert(filename);
854 assert(lvalue);
855 assert(rvalue);
856 assert(data);
857
858 cap = cap_from_text(rvalue);
859 if (!cap) {
860 log_syntax(unit, LOG_ERR, filename, line, errno,
861 "Failed to parse capabilities, ignoring: %s", rvalue);
862 return 0;
863 }
864
865 if (c->capabilities)
866 cap_free(c->capabilities);
867 c->capabilities = cap;
868
869 return 0;
870 }
871
872 int config_parse_exec_secure_bits(const char *unit,
873 const char *filename,
874 unsigned line,
875 const char *section,
876 unsigned section_line,
877 const char *lvalue,
878 int ltype,
879 const char *rvalue,
880 void *data,
881 void *userdata) {
882
883 ExecContext *c = data;
884 char *w;
885 size_t l;
886 char *state;
887
888 assert(filename);
889 assert(lvalue);
890 assert(rvalue);
891 assert(data);
892
893 if (isempty(rvalue)) {
894 /* An empty assignment resets the field */
895 c->secure_bits = 0;
896 return 0;
897 }
898
899 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
900 if (first_word(w, "keep-caps"))
901 c->secure_bits |= 1<<SECURE_KEEP_CAPS;
902 else if (first_word(w, "keep-caps-locked"))
903 c->secure_bits |= 1<<SECURE_KEEP_CAPS_LOCKED;
904 else if (first_word(w, "no-setuid-fixup"))
905 c->secure_bits |= 1<<SECURE_NO_SETUID_FIXUP;
906 else if (first_word(w, "no-setuid-fixup-locked"))
907 c->secure_bits |= 1<<SECURE_NO_SETUID_FIXUP_LOCKED;
908 else if (first_word(w, "noroot"))
909 c->secure_bits |= 1<<SECURE_NOROOT;
910 else if (first_word(w, "noroot-locked"))
911 c->secure_bits |= 1<<SECURE_NOROOT_LOCKED;
912 else {
913 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
914 "Failed to parse secure bits, ignoring: %s", rvalue);
915 return 0;
916 }
917 }
918
919 return 0;
920 }
921
922 int config_parse_bounding_set(const char *unit,
923 const char *filename,
924 unsigned line,
925 const char *section,
926 unsigned section_line,
927 const char *lvalue,
928 int ltype,
929 const char *rvalue,
930 void *data,
931 void *userdata) {
932
933 uint64_t *capability_bounding_set_drop = data;
934 char *w;
935 size_t l;
936 char *state;
937 bool invert = false;
938 uint64_t sum = 0;
939
940 assert(filename);
941 assert(lvalue);
942 assert(rvalue);
943 assert(data);
944
945 if (rvalue[0] == '~') {
946 invert = true;
947 rvalue++;
948 }
949
950 /* Note that we store this inverted internally, since the
951 * kernel wants it like this. But we actually expose it
952 * non-inverted everywhere to have a fully normalized
953 * interface. */
954
955 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
956 _cleanup_free_ char *t = NULL;
957 int r;
958 cap_value_t cap;
959
960 t = strndup(w, l);
961 if (!t)
962 return log_oom();
963
964 r = cap_from_name(t, &cap);
965 if (r < 0) {
966 log_syntax(unit, LOG_ERR, filename, line, errno,
967 "Failed to parse capability in bounding set, ignoring: %s", t);
968 continue;
969 }
970
971 sum |= ((uint64_t) 1ULL) << (uint64_t) cap;
972 }
973
974 if (invert)
975 *capability_bounding_set_drop |= sum;
976 else
977 *capability_bounding_set_drop |= ~sum;
978
979 return 0;
980 }
981
982 int config_parse_limit(const char *unit,
983 const char *filename,
984 unsigned line,
985 const char *section,
986 unsigned section_line,
987 const char *lvalue,
988 int ltype,
989 const char *rvalue,
990 void *data,
991 void *userdata) {
992
993 struct rlimit **rl = data;
994 unsigned long long u;
995
996 assert(filename);
997 assert(lvalue);
998 assert(rvalue);
999 assert(data);
1000
1001 rl += ltype;
1002
1003 if (streq(rvalue, "infinity"))
1004 u = (unsigned long long) RLIM_INFINITY;
1005 else {
1006 int r;
1007
1008 r = safe_atollu(rvalue, &u);
1009 if (r < 0) {
1010 log_syntax(unit, LOG_ERR, filename, line, -r,
1011 "Failed to parse resource value, ignoring: %s", rvalue);
1012 return 0;
1013 }
1014 }
1015
1016 if (!*rl) {
1017 *rl = new(struct rlimit, 1);
1018 if (!*rl)
1019 return log_oom();
1020 }
1021
1022 (*rl)->rlim_cur = (*rl)->rlim_max = (rlim_t) u;
1023 return 0;
1024 }
1025
1026 #ifdef HAVE_SYSV_COMPAT
1027 int config_parse_sysv_priority(const char *unit,
1028 const char *filename,
1029 unsigned line,
1030 const char *section,
1031 unsigned section_line,
1032 const char *lvalue,
1033 int ltype,
1034 const char *rvalue,
1035 void *data,
1036 void *userdata) {
1037
1038 int *priority = data;
1039 int i, r;
1040
1041 assert(filename);
1042 assert(lvalue);
1043 assert(rvalue);
1044 assert(data);
1045
1046 r = safe_atoi(rvalue, &i);
1047 if (r < 0 || i < 0) {
1048 log_syntax(unit, LOG_ERR, filename, line, -r,
1049 "Failed to parse SysV start priority, ignoring: %s", rvalue);
1050 return 0;
1051 }
1052
1053 *priority = (int) i;
1054 return 0;
1055 }
1056 #endif
1057
1058 DEFINE_CONFIG_PARSE_ENUM(config_parse_kill_mode, kill_mode, KillMode, "Failed to parse kill mode");
1059
1060 int config_parse_kill_signal(const char *unit,
1061 const char *filename,
1062 unsigned line,
1063 const char *section,
1064 unsigned section_line,
1065 const char *lvalue,
1066 int ltype,
1067 const char *rvalue,
1068 void *data,
1069 void *userdata) {
1070
1071 int *sig = data;
1072 int r;
1073
1074 assert(filename);
1075 assert(lvalue);
1076 assert(rvalue);
1077 assert(sig);
1078
1079 r = signal_from_string_try_harder(rvalue);
1080 if (r <= 0) {
1081 log_syntax(unit, LOG_ERR, filename, line, -r,
1082 "Failed to parse kill signal, ignoring: %s", rvalue);
1083 return 0;
1084 }
1085
1086 *sig = r;
1087 return 0;
1088 }
1089
1090 int config_parse_exec_mount_flags(const char *unit,
1091 const char *filename,
1092 unsigned line,
1093 const char *section,
1094 unsigned section_line,
1095 const char *lvalue,
1096 int ltype,
1097 const char *rvalue,
1098 void *data,
1099 void *userdata) {
1100
1101 ExecContext *c = data;
1102 char *w;
1103 size_t l;
1104 char *state;
1105 unsigned long flags = 0;
1106
1107 assert(filename);
1108 assert(lvalue);
1109 assert(rvalue);
1110 assert(data);
1111
1112 FOREACH_WORD_SEPARATOR(w, l, rvalue, ", ", state) {
1113 _cleanup_free_ char *t;
1114
1115 t = strndup(w, l);
1116 if (!t)
1117 return log_oom();
1118
1119 if (streq(t, "shared"))
1120 flags |= MS_SHARED;
1121 else if (streq(t, "slave"))
1122 flags |= MS_SLAVE;
1123 else if (streq(w, "private"))
1124 flags |= MS_PRIVATE;
1125 else {
1126 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1127 "Failed to parse mount flag %s, ignoring: %s",
1128 t, rvalue);
1129 return 0;
1130 }
1131 }
1132
1133 c->mount_flags = flags;
1134 return 0;
1135 }
1136
1137 int config_parse_timer(const char *unit,
1138 const char *filename,
1139 unsigned line,
1140 const char *section,
1141 unsigned section_line,
1142 const char *lvalue,
1143 int ltype,
1144 const char *rvalue,
1145 void *data,
1146 void *userdata) {
1147
1148 Timer *t = data;
1149 usec_t u = 0;
1150 TimerValue *v;
1151 TimerBase b;
1152 CalendarSpec *c = NULL;
1153 clockid_t id;
1154
1155 assert(filename);
1156 assert(lvalue);
1157 assert(rvalue);
1158 assert(data);
1159
1160 if (isempty(rvalue)) {
1161 /* Empty assignment resets list */
1162 timer_free_values(t);
1163 return 0;
1164 }
1165
1166 b = timer_base_from_string(lvalue);
1167 if (b < 0) {
1168 log_syntax(unit, LOG_ERR, filename, line, -b,
1169 "Failed to parse timer base, ignoring: %s", lvalue);
1170 return 0;
1171 }
1172
1173 if (b == TIMER_CALENDAR) {
1174 if (calendar_spec_from_string(rvalue, &c) < 0) {
1175 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1176 "Failed to parse calendar specification, ignoring: %s",
1177 rvalue);
1178 return 0;
1179 }
1180
1181 id = CLOCK_REALTIME;
1182 } else {
1183 if (parse_sec(rvalue, &u) < 0) {
1184 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1185 "Failed to parse timer value, ignoring: %s",
1186 rvalue);
1187 return 0;
1188 }
1189
1190 id = CLOCK_MONOTONIC;
1191 }
1192
1193 v = new0(TimerValue, 1);
1194 if (!v)
1195 return log_oom();
1196
1197 v->base = b;
1198 v->clock_id = id;
1199 v->value = u;
1200 v->calendar_spec = c;
1201
1202 LIST_PREPEND(value, t->values, v);
1203
1204 return 0;
1205 }
1206
1207 int config_parse_trigger_unit(
1208 const char *unit,
1209 const char *filename,
1210 unsigned line,
1211 const char *section,
1212 unsigned section_line,
1213 const char *lvalue,
1214 int ltype,
1215 const char *rvalue,
1216 void *data,
1217 void *userdata) {
1218
1219 _cleanup_free_ char *p = NULL;
1220 Unit *u = data;
1221 UnitType type;
1222 int r;
1223
1224 assert(filename);
1225 assert(lvalue);
1226 assert(rvalue);
1227 assert(data);
1228
1229 if (!set_isempty(u->dependencies[UNIT_TRIGGERS])) {
1230 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1231 "Multiple units to trigger specified, ignoring: %s", rvalue);
1232 return 0;
1233 }
1234
1235 r = unit_name_printf(u, rvalue, &p);
1236 if (r < 0)
1237 log_syntax(unit, LOG_ERR, filename, line, -r,
1238 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
1239
1240 type = unit_name_to_type(p ?: rvalue);
1241 if (type < 0) {
1242 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1243 "Unit type not valid, ignoring: %s", rvalue);
1244 return 0;
1245 }
1246
1247 if (type == u->type) {
1248 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1249 "Trigger cannot be of same type, ignoring: %s", rvalue);
1250 return 0;
1251 }
1252
1253 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_TRIGGERS, p ?: rvalue, NULL, true);
1254 if (r < 0) {
1255 log_syntax(unit, LOG_ERR, filename, line, -r,
1256 "Failed to add trigger on %s, ignoring: %s", p ?: rvalue, strerror(-r));
1257 return 0;
1258 }
1259
1260 return 0;
1261 }
1262
1263 int config_parse_path_spec(const char *unit,
1264 const char *filename,
1265 unsigned line,
1266 const char *section,
1267 unsigned section_line,
1268 const char *lvalue,
1269 int ltype,
1270 const char *rvalue,
1271 void *data,
1272 void *userdata) {
1273
1274 Path *p = data;
1275 PathSpec *s;
1276 PathType b;
1277 _cleanup_free_ char *k = NULL;
1278 int r;
1279
1280 assert(filename);
1281 assert(lvalue);
1282 assert(rvalue);
1283 assert(data);
1284
1285 if (isempty(rvalue)) {
1286 /* Empty assignment clears list */
1287 path_free_specs(p);
1288 return 0;
1289 }
1290
1291 b = path_type_from_string(lvalue);
1292 if (b < 0) {
1293 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1294 "Failed to parse path type, ignoring: %s", lvalue);
1295 return 0;
1296 }
1297
1298 r = unit_full_printf(UNIT(p), rvalue, &k);
1299 if (r < 0) {
1300 k = strdup(rvalue);
1301 if (!k)
1302 return log_oom();
1303 else
1304 log_syntax(unit, LOG_ERR, filename, line, -r,
1305 "Failed to resolve unit specifiers on %s. Ignoring.",
1306 rvalue);
1307 }
1308
1309 if (!path_is_absolute(k)) {
1310 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1311 "Path is not absolute, ignoring: %s", k);
1312 return 0;
1313 }
1314
1315 s = new0(PathSpec, 1);
1316 if (!s)
1317 return log_oom();
1318
1319 s->unit = UNIT(p);
1320 s->path = path_kill_slashes(k);
1321 k = NULL;
1322 s->type = b;
1323 s->inotify_fd = -1;
1324
1325 LIST_PREPEND(spec, p->specs, s);
1326
1327 return 0;
1328 }
1329
1330 int config_parse_socket_service(const char *unit,
1331 const char *filename,
1332 unsigned line,
1333 const char *section,
1334 unsigned section_line,
1335 const char *lvalue,
1336 int ltype,
1337 const char *rvalue,
1338 void *data,
1339 void *userdata) {
1340
1341 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1342 Socket *s = data;
1343 int r;
1344 Unit *x;
1345 _cleanup_free_ char *p = NULL;
1346
1347 assert(filename);
1348 assert(lvalue);
1349 assert(rvalue);
1350 assert(data);
1351
1352 r = unit_name_printf(UNIT(s), rvalue, &p);
1353 if (r < 0) {
1354 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve specifiers, ignoring: %s", rvalue);
1355 return 0;
1356 }
1357
1358 if (!endswith(p, ".service")) {
1359 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Unit must be of type service, ignoring: %s", rvalue);
1360 return 0;
1361 }
1362
1363 r = manager_load_unit(UNIT(s)->manager, p, NULL, &error, &x);
1364 if (r < 0) {
1365 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to load unit %s, ignoring: %s", rvalue, bus_error_message(&error, r));
1366 return 0;
1367 }
1368
1369 unit_ref_set(&s->service, x);
1370
1371 return 0;
1372 }
1373
1374 int config_parse_service_sockets(const char *unit,
1375 const char *filename,
1376 unsigned line,
1377 const char *section,
1378 unsigned section_line,
1379 const char *lvalue,
1380 int ltype,
1381 const char *rvalue,
1382 void *data,
1383 void *userdata) {
1384
1385 Service *s = data;
1386 int r;
1387 char *state, *w;
1388 size_t l;
1389
1390 assert(filename);
1391 assert(lvalue);
1392 assert(rvalue);
1393 assert(data);
1394
1395 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
1396 _cleanup_free_ char *t = NULL, *k = NULL;
1397
1398 t = strndup(w, l);
1399 if (!t)
1400 return log_oom();
1401
1402 r = unit_name_printf(UNIT(s), t, &k);
1403 if (r < 0)
1404 log_syntax(unit, LOG_ERR, filename, line, -r,
1405 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
1406
1407 if (!endswith(k ?: t, ".socket")) {
1408 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1409 "Unit must be of type socket, ignoring: %s", k ?: t);
1410 continue;
1411 }
1412
1413 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_WANTS, UNIT_AFTER, k ?: t, NULL, true);
1414 if (r < 0)
1415 log_syntax(unit, LOG_ERR, filename, line, -r,
1416 "Failed to add dependency on %s, ignoring: %s",
1417 k ?: t, strerror(-r));
1418
1419 r = unit_add_dependency_by_name(UNIT(s), UNIT_TRIGGERED_BY, k ?: t, NULL, true);
1420 if (r < 0)
1421 return r;
1422 }
1423
1424 return 0;
1425 }
1426
1427 int config_parse_service_timeout(const char *unit,
1428 const char *filename,
1429 unsigned line,
1430 const char *section,
1431 unsigned section_line,
1432 const char *lvalue,
1433 int ltype,
1434 const char *rvalue,
1435 void *data,
1436 void *userdata) {
1437
1438 Service *s = userdata;
1439 int r;
1440
1441 assert(filename);
1442 assert(lvalue);
1443 assert(rvalue);
1444 assert(s);
1445
1446 r = config_parse_sec(unit, filename, line, section, section_line, lvalue, ltype,
1447 rvalue, data, userdata);
1448 if (r < 0)
1449 return r;
1450
1451 if (streq(lvalue, "TimeoutSec")) {
1452 s->start_timeout_defined = true;
1453 s->timeout_stop_usec = s->timeout_start_usec;
1454 } else if (streq(lvalue, "TimeoutStartSec"))
1455 s->start_timeout_defined = true;
1456
1457 return 0;
1458 }
1459
1460 int config_parse_busname_service(
1461 const char *unit,
1462 const char *filename,
1463 unsigned line,
1464 const char *section,
1465 unsigned section_line,
1466 const char *lvalue,
1467 int ltype,
1468 const char *rvalue,
1469 void *data,
1470 void *userdata) {
1471
1472 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1473 BusName *n = data;
1474 int r;
1475 Unit *x;
1476 _cleanup_free_ char *p = NULL;
1477
1478 assert(filename);
1479 assert(lvalue);
1480 assert(rvalue);
1481 assert(data);
1482
1483 r = unit_name_printf(UNIT(n), rvalue, &p);
1484 if (r < 0) {
1485 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve specifiers, ignoring: %s", rvalue);
1486 return 0;
1487 }
1488
1489 if (!endswith(p, ".service")) {
1490 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Unit must be of type service, ignoring: %s", rvalue);
1491 return 0;
1492 }
1493
1494 r = manager_load_unit(UNIT(n)->manager, p, NULL, &error, &x);
1495 if (r < 0) {
1496 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to load unit %s, ignoring: %s", rvalue, bus_error_message(&error, r));
1497 return 0;
1498 }
1499
1500 unit_ref_set(&n->service, x);
1501
1502 return 0;
1503 }
1504
1505 int config_parse_unit_env_file(const char *unit,
1506 const char *filename,
1507 unsigned line,
1508 const char *section,
1509 unsigned section_line,
1510 const char *lvalue,
1511 int ltype,
1512 const char *rvalue,
1513 void *data,
1514 void *userdata) {
1515
1516 char ***env = data;
1517 Unit *u = userdata;
1518 _cleanup_free_ char *n = NULL;
1519 const char *s;
1520 int r;
1521
1522 assert(filename);
1523 assert(lvalue);
1524 assert(rvalue);
1525 assert(data);
1526
1527 if (isempty(rvalue)) {
1528 /* Empty assignment frees the list */
1529 strv_free(*env);
1530 *env = NULL;
1531 return 0;
1532 }
1533
1534 r = unit_full_printf(u, rvalue, &n);
1535 if (r < 0)
1536 log_syntax(unit, LOG_ERR, filename, line, r,
1537 "Failed to resolve specifiers, ignoring: %s", rvalue);
1538
1539 s = n ?: rvalue;
1540 if (!path_is_absolute(s[0] == '-' ? s + 1 : s)) {
1541 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1542 "Path '%s' is not absolute, ignoring.", s);
1543 return 0;
1544 }
1545
1546 r = strv_extend(env, s);
1547 if (r < 0)
1548 return log_oom();
1549
1550 return 0;
1551 }
1552
1553 int config_parse_environ(const char *unit,
1554 const char *filename,
1555 unsigned line,
1556 const char *section,
1557 unsigned section_line,
1558 const char *lvalue,
1559 int ltype,
1560 const char *rvalue,
1561 void *data,
1562 void *userdata) {
1563
1564 Unit *u = userdata;
1565 char*** env = data, *w, *state;
1566 size_t l;
1567 _cleanup_free_ char *k = NULL;
1568 int r;
1569
1570 assert(filename);
1571 assert(lvalue);
1572 assert(rvalue);
1573 assert(data);
1574
1575 if (isempty(rvalue)) {
1576 /* Empty assignment resets the list */
1577 strv_free(*env);
1578 *env = NULL;
1579 return 0;
1580 }
1581
1582 if (u) {
1583 r = unit_full_printf(u, rvalue, &k);
1584 if (r < 0)
1585 log_syntax(unit, LOG_ERR, filename, line, -r,
1586 "Failed to resolve specifiers, ignoring: %s", rvalue);
1587 }
1588
1589 if (!k)
1590 k = strdup(rvalue);
1591 if (!k)
1592 return log_oom();
1593
1594 FOREACH_WORD_QUOTED(w, l, k, state) {
1595 _cleanup_free_ char *n;
1596 char **x;
1597
1598 n = cunescape_length(w, l);
1599 if (!n)
1600 return log_oom();
1601
1602 if (!env_assignment_is_valid(n)) {
1603 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1604 "Invalid environment assignment, ignoring: %s", rvalue);
1605 continue;
1606 }
1607
1608 x = strv_env_set(*env, n);
1609 if (!x)
1610 return log_oom();
1611
1612 strv_free(*env);
1613 *env = x;
1614 }
1615
1616 return 0;
1617 }
1618
1619 int config_parse_ip_tos(const char *unit,
1620 const char *filename,
1621 unsigned line,
1622 const char *section,
1623 unsigned section_line,
1624 const char *lvalue,
1625 int ltype,
1626 const char *rvalue,
1627 void *data,
1628 void *userdata) {
1629
1630 int *ip_tos = data, x;
1631
1632 assert(filename);
1633 assert(lvalue);
1634 assert(rvalue);
1635 assert(data);
1636
1637 x = ip_tos_from_string(rvalue);
1638 if (x < 0) {
1639 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1640 "Failed to parse IP TOS value, ignoring: %s", rvalue);
1641 return 0;
1642 }
1643
1644 *ip_tos = x;
1645 return 0;
1646 }
1647
1648 int config_parse_unit_condition_path(const char *unit,
1649 const char *filename,
1650 unsigned line,
1651 const char *section,
1652 unsigned section_line,
1653 const char *lvalue,
1654 int ltype,
1655 const char *rvalue,
1656 void *data,
1657 void *userdata) {
1658
1659 ConditionType cond = ltype;
1660 Unit *u = data;
1661 bool trigger, negate;
1662 Condition *c;
1663 _cleanup_free_ char *p = NULL;
1664 int r;
1665
1666 assert(filename);
1667 assert(lvalue);
1668 assert(rvalue);
1669 assert(data);
1670
1671 if (isempty(rvalue)) {
1672 /* Empty assignment resets the list */
1673 condition_free_list(u->conditions);
1674 u->conditions = NULL;
1675 return 0;
1676 }
1677
1678 trigger = rvalue[0] == '|';
1679 if (trigger)
1680 rvalue++;
1681
1682 negate = rvalue[0] == '!';
1683 if (negate)
1684 rvalue++;
1685
1686 r = unit_full_printf(u, rvalue, &p);
1687 if (r < 0)
1688 log_syntax(unit, LOG_ERR, filename, line, -r,
1689 "Failed to resolve specifiers, ignoring: %s", rvalue);
1690 if (!p) {
1691 p = strdup(rvalue);
1692 if (!p)
1693 return log_oom();
1694 }
1695
1696 if (!path_is_absolute(p)) {
1697 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1698 "Path in condition not absolute, ignoring: %s", p);
1699 return 0;
1700 }
1701
1702 c = condition_new(cond, p, trigger, negate);
1703 if (!c)
1704 return log_oom();
1705
1706 LIST_PREPEND(conditions, u->conditions, c);
1707 return 0;
1708 }
1709
1710 int config_parse_unit_condition_string(const char *unit,
1711 const char *filename,
1712 unsigned line,
1713 const char *section,
1714 unsigned section_line,
1715 const char *lvalue,
1716 int ltype,
1717 const char *rvalue,
1718 void *data,
1719 void *userdata) {
1720
1721 ConditionType cond = ltype;
1722 Unit *u = data;
1723 bool trigger, negate;
1724 Condition *c;
1725 _cleanup_free_ char *s = NULL;
1726 int r;
1727
1728 assert(filename);
1729 assert(lvalue);
1730 assert(rvalue);
1731 assert(data);
1732
1733 if (isempty(rvalue)) {
1734 /* Empty assignment resets the list */
1735 condition_free_list(u->conditions);
1736 u->conditions = NULL;
1737 return 0;
1738 }
1739
1740 trigger = rvalue[0] == '|';
1741 if (trigger)
1742 rvalue++;
1743
1744 negate = rvalue[0] == '!';
1745 if (negate)
1746 rvalue++;
1747
1748 r = unit_full_printf(u, rvalue, &s);
1749 if (r < 0)
1750 log_syntax(unit, LOG_ERR, filename, line, -r,
1751 "Failed to resolve specifiers, ignoring: %s", rvalue);
1752 if (!s) {
1753 s = strdup(rvalue);
1754 if (!s)
1755 return log_oom();
1756 }
1757
1758 c = condition_new(cond, s, trigger, negate);
1759 if (!c)
1760 return log_oom();
1761
1762 LIST_PREPEND(conditions, u->conditions, c);
1763 return 0;
1764 }
1765
1766 int config_parse_unit_condition_null(const char *unit,
1767 const char *filename,
1768 unsigned line,
1769 const char *section,
1770 unsigned section_line,
1771 const char *lvalue,
1772 int ltype,
1773 const char *rvalue,
1774 void *data,
1775 void *userdata) {
1776
1777 Unit *u = data;
1778 Condition *c;
1779 bool trigger, negate;
1780 int b;
1781
1782 assert(filename);
1783 assert(lvalue);
1784 assert(rvalue);
1785 assert(data);
1786
1787 if (isempty(rvalue)) {
1788 /* Empty assignment resets the list */
1789 condition_free_list(u->conditions);
1790 u->conditions = NULL;
1791 return 0;
1792 }
1793
1794 trigger = rvalue[0] == '|';
1795 if (trigger)
1796 rvalue++;
1797
1798 negate = rvalue[0] == '!';
1799 if (negate)
1800 rvalue++;
1801
1802 b = parse_boolean(rvalue);
1803 if (b < 0) {
1804 log_syntax(unit, LOG_ERR, filename, line, -b,
1805 "Failed to parse boolean value in condition, ignoring: %s",
1806 rvalue);
1807 return 0;
1808 }
1809
1810 if (!b)
1811 negate = !negate;
1812
1813 c = condition_new(CONDITION_NULL, NULL, trigger, negate);
1814 if (!c)
1815 return log_oom();
1816
1817 LIST_PREPEND(conditions, u->conditions, c);
1818 return 0;
1819 }
1820
1821 DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier");
1822 DEFINE_CONFIG_PARSE_ENUM(config_parse_start_limit_action, start_limit_action, StartLimitAction, "Failed to parse start limit action specifier");
1823
1824 int config_parse_unit_requires_mounts_for(
1825 const char *unit,
1826 const char *filename,
1827 unsigned line,
1828 const char *section,
1829 unsigned section_line,
1830 const char *lvalue,
1831 int ltype,
1832 const char *rvalue,
1833 void *data,
1834 void *userdata) {
1835
1836 Unit *u = userdata;
1837 char *state;
1838 size_t l;
1839 char *w;
1840
1841 assert(filename);
1842 assert(lvalue);
1843 assert(rvalue);
1844 assert(data);
1845
1846 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
1847 int r;
1848 _cleanup_free_ char *n;
1849
1850 n = strndup(w, l);
1851 if (!n)
1852 return log_oom();
1853
1854 if (!utf8_is_valid(n)) {
1855 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1856 "Path is not UTF-8 clean, ignoring assignment: %s", rvalue);
1857 continue;
1858 }
1859
1860 r = unit_require_mounts_for(u, n);
1861 if (r < 0) {
1862 log_syntax(unit, LOG_ERR, filename, line, r,
1863 "Failed to add required mount for, ignoring: %s", rvalue);
1864 continue;
1865 }
1866 }
1867
1868 return 0;
1869 }
1870
1871 int config_parse_documentation(const char *unit,
1872 const char *filename,
1873 unsigned line,
1874 const char *section,
1875 unsigned section_line,
1876 const char *lvalue,
1877 int ltype,
1878 const char *rvalue,
1879 void *data,
1880 void *userdata) {
1881
1882 Unit *u = userdata;
1883 int r;
1884 char **a, **b;
1885
1886 assert(filename);
1887 assert(lvalue);
1888 assert(rvalue);
1889 assert(u);
1890
1891 if (isempty(rvalue)) {
1892 /* Empty assignment resets the list */
1893 strv_free(u->documentation);
1894 u->documentation = NULL;
1895 return 0;
1896 }
1897
1898 r = config_parse_unit_strv_printf(unit, filename, line, section, section_line, lvalue, ltype,
1899 rvalue, data, userdata);
1900 if (r < 0)
1901 return r;
1902
1903 for (a = b = u->documentation; a && *a; a++) {
1904
1905 if (is_valid_documentation_url(*a))
1906 *(b++) = *a;
1907 else {
1908 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1909 "Invalid URL, ignoring: %s", *a);
1910 free(*a);
1911 }
1912 }
1913 if (b)
1914 *b = NULL;
1915
1916 return r;
1917 }
1918
1919 static void syscall_set(uint32_t *p, int nr) {
1920 nr = SYSCALL_TO_INDEX(nr);
1921 p[nr >> 4] |= 1 << (nr & 31);
1922 }
1923
1924 static void syscall_unset(uint32_t *p, int nr) {
1925 nr = SYSCALL_TO_INDEX(nr);
1926 p[nr >> 4] &= ~(1 << (nr & 31));
1927 }
1928
1929 int config_parse_syscall_filter(const char *unit,
1930 const char *filename,
1931 unsigned line,
1932 const char *section,
1933 unsigned section_line,
1934 const char *lvalue,
1935 int ltype,
1936 const char *rvalue,
1937 void *data,
1938 void *userdata) {
1939
1940 ExecContext *c = data;
1941 Unit *u = userdata;
1942 bool invert = false;
1943 char *w;
1944 size_t l;
1945 char *state;
1946
1947 assert(filename);
1948 assert(lvalue);
1949 assert(rvalue);
1950 assert(u);
1951
1952 if (isempty(rvalue)) {
1953 /* Empty assignment resets the list */
1954 free(c->syscall_filter);
1955 c->syscall_filter = NULL;
1956 return 0;
1957 }
1958
1959 if (rvalue[0] == '~') {
1960 invert = true;
1961 rvalue++;
1962 }
1963
1964 if (!c->syscall_filter) {
1965 size_t n;
1966
1967 n = (syscall_max() + 31) >> 4;
1968 c->syscall_filter = new(uint32_t, n);
1969 if (!c->syscall_filter)
1970 return log_oom();
1971
1972 memset(c->syscall_filter, invert ? 0xFF : 0, n * sizeof(uint32_t));
1973
1974 /* Add these by default */
1975 syscall_set(c->syscall_filter, __NR_execve);
1976 syscall_set(c->syscall_filter, __NR_rt_sigreturn);
1977 #ifdef __NR_sigreturn
1978 syscall_set(c->syscall_filter, __NR_sigreturn);
1979 #endif
1980 syscall_set(c->syscall_filter, __NR_exit_group);
1981 syscall_set(c->syscall_filter, __NR_exit);
1982 }
1983
1984 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
1985 int id;
1986 _cleanup_free_ char *t = NULL;
1987
1988 t = strndup(w, l);
1989 if (!t)
1990 return log_oom();
1991
1992 id = syscall_from_name(t);
1993 if (id < 0) {
1994 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1995 "Failed to parse syscall, ignoring: %s", t);
1996 continue;
1997 }
1998
1999 if (invert)
2000 syscall_unset(c->syscall_filter, id);
2001 else
2002 syscall_set(c->syscall_filter, id);
2003 }
2004
2005 c->no_new_privileges = true;
2006
2007 return 0;
2008 }
2009
2010 int config_parse_unit_slice(
2011 const char *unit,
2012 const char *filename,
2013 unsigned line,
2014 const char *section,
2015 unsigned section_line,
2016 const char *lvalue,
2017 int ltype,
2018 const char *rvalue,
2019 void *data,
2020 void *userdata) {
2021
2022 _cleanup_free_ char *k = NULL;
2023 Unit *u = userdata, *slice;
2024 int r;
2025
2026 assert(filename);
2027 assert(lvalue);
2028 assert(rvalue);
2029 assert(u);
2030
2031 r = unit_name_printf(u, rvalue, &k);
2032 if (r < 0)
2033 log_syntax(unit, LOG_ERR, filename, line, -r,
2034 "Failed to resolve unit specifiers on %s. Ignoring.", rvalue);
2035 if (!k) {
2036 k = strdup(rvalue);
2037 if (!k)
2038 return log_oom();
2039 }
2040
2041 r = manager_load_unit(u->manager, k, NULL, NULL, &slice);
2042 if (r < 0) {
2043 log_syntax(unit, LOG_ERR, filename, line, -r,
2044 "Failed to load slice unit %s. Ignoring.", k);
2045 return 0;
2046 }
2047
2048 if (slice->type != UNIT_SLICE) {
2049 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2050 "Slice unit %s is not a slice. Ignoring.", k);
2051 return 0;
2052 }
2053
2054 unit_ref_set(&u->slice, slice);
2055 return 0;
2056 }
2057
2058 DEFINE_CONFIG_PARSE_ENUM(config_parse_device_policy, cgroup_device_policy, CGroupDevicePolicy, "Failed to parse device policy");
2059
2060 int config_parse_cpu_shares(
2061 const char *unit,
2062 const char *filename,
2063 unsigned line,
2064 const char *section,
2065 unsigned section_line,
2066 const char *lvalue,
2067 int ltype,
2068 const char *rvalue,
2069 void *data,
2070 void *userdata) {
2071
2072 CGroupContext *c = data;
2073 unsigned long lu;
2074 int r;
2075
2076 assert(filename);
2077 assert(lvalue);
2078 assert(rvalue);
2079
2080 if (isempty(rvalue)) {
2081 c->cpu_shares = 1024;
2082 return 0;
2083 }
2084
2085 r = safe_atolu(rvalue, &lu);
2086 if (r < 0 || lu <= 0) {
2087 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2088 "CPU shares '%s' invalid. Ignoring.", rvalue);
2089 return 0;
2090 }
2091
2092 c->cpu_shares = lu;
2093 return 0;
2094 }
2095
2096 int config_parse_memory_limit(
2097 const char *unit,
2098 const char *filename,
2099 unsigned line,
2100 const char *section,
2101 unsigned section_line,
2102 const char *lvalue,
2103 int ltype,
2104 const char *rvalue,
2105 void *data,
2106 void *userdata) {
2107
2108 CGroupContext *c = data;
2109 off_t bytes;
2110 int r;
2111
2112 if (isempty(rvalue)) {
2113 c->memory_limit = (uint64_t) -1;
2114 return 0;
2115 }
2116
2117 assert_cc(sizeof(uint64_t) == sizeof(off_t));
2118
2119 r = parse_bytes(rvalue, &bytes);
2120 if (r < 0) {
2121 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2122 "Memory limit '%s' invalid. Ignoring.", rvalue);
2123 return 0;
2124 }
2125
2126 c->memory_limit = (uint64_t) bytes;
2127 return 0;
2128 }
2129
2130 int config_parse_device_allow(
2131 const char *unit,
2132 const char *filename,
2133 unsigned line,
2134 const char *section,
2135 unsigned section_line,
2136 const char *lvalue,
2137 int ltype,
2138 const char *rvalue,
2139 void *data,
2140 void *userdata) {
2141
2142 _cleanup_free_ char *path = NULL;
2143 CGroupContext *c = data;
2144 CGroupDeviceAllow *a;
2145 const char *m;
2146 size_t n;
2147
2148 if (isempty(rvalue)) {
2149 while (c->device_allow)
2150 cgroup_context_free_device_allow(c, c->device_allow);
2151
2152 return 0;
2153 }
2154
2155 n = strcspn(rvalue, WHITESPACE);
2156 path = strndup(rvalue, n);
2157 if (!path)
2158 return log_oom();
2159
2160 if (!path_startswith(path, "/dev")) {
2161 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2162 "Invalid device node path '%s'. Ignoring.", path);
2163 return 0;
2164 }
2165
2166 m = rvalue + n + strspn(rvalue + n, WHITESPACE);
2167 if (isempty(m))
2168 m = "rwm";
2169
2170 if (!in_charset(m, "rwm")) {
2171 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2172 "Invalid device rights '%s'. Ignoring.", m);
2173 return 0;
2174 }
2175
2176 a = new0(CGroupDeviceAllow, 1);
2177 if (!a)
2178 return log_oom();
2179
2180 a->path = path;
2181 path = NULL;
2182 a->r = !!strchr(m, 'r');
2183 a->w = !!strchr(m, 'w');
2184 a->m = !!strchr(m, 'm');
2185
2186 LIST_PREPEND(device_allow, c->device_allow, a);
2187 return 0;
2188 }
2189
2190 int config_parse_blockio_weight(
2191 const char *unit,
2192 const char *filename,
2193 unsigned line,
2194 const char *section,
2195 unsigned section_line,
2196 const char *lvalue,
2197 int ltype,
2198 const char *rvalue,
2199 void *data,
2200 void *userdata) {
2201
2202 CGroupContext *c = data;
2203 unsigned long lu;
2204 int r;
2205
2206 assert(filename);
2207 assert(lvalue);
2208 assert(rvalue);
2209
2210 if (isempty(rvalue)) {
2211 c->blockio_weight = 1000;
2212 return 0;
2213 }
2214
2215 r = safe_atolu(rvalue, &lu);
2216 if (r < 0 || lu < 10 || lu > 1000) {
2217 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2218 "Block IO weight '%s' invalid. Ignoring.", rvalue);
2219 return 0;
2220 }
2221
2222 c->blockio_weight = lu;
2223
2224 return 0;
2225 }
2226
2227 int config_parse_blockio_device_weight(
2228 const char *unit,
2229 const char *filename,
2230 unsigned line,
2231 const char *section,
2232 unsigned section_line,
2233 const char *lvalue,
2234 int ltype,
2235 const char *rvalue,
2236 void *data,
2237 void *userdata) {
2238
2239 _cleanup_free_ char *path = NULL;
2240 CGroupBlockIODeviceWeight *w;
2241 CGroupContext *c = data;
2242 unsigned long lu;
2243 const char *weight;
2244 size_t n;
2245 int r;
2246
2247 assert(filename);
2248 assert(lvalue);
2249 assert(rvalue);
2250
2251 if (isempty(rvalue)) {
2252 while (c->blockio_device_weights)
2253 cgroup_context_free_blockio_device_weight(c, c->blockio_device_weights);
2254
2255 return 0;
2256 }
2257
2258 n = strcspn(rvalue, WHITESPACE);
2259 weight = rvalue + n;
2260 if (!*weight) {
2261 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2262 "Expected block device and device weight. Ignoring.");
2263 return 0;
2264 }
2265
2266 path = strndup(rvalue, n);
2267 if (!path)
2268 return log_oom();
2269
2270 if (!path_startswith(path, "/dev")) {
2271 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2272 "Invalid device node path '%s'. Ignoring.", path);
2273 return 0;
2274 }
2275
2276 weight += strspn(weight, WHITESPACE);
2277 r = safe_atolu(weight, &lu);
2278 if (r < 0 || lu < 10 || lu > 1000) {
2279 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2280 "Block IO weight '%s' invalid. Ignoring.", rvalue);
2281 return 0;
2282 }
2283
2284
2285 w = new0(CGroupBlockIODeviceWeight, 1);
2286 if (!w)
2287 return log_oom();
2288
2289 w->path = path;
2290 path = NULL;
2291
2292 w->weight = lu;
2293
2294 LIST_PREPEND(device_weights, c->blockio_device_weights, w);
2295 return 0;
2296 }
2297
2298 int config_parse_blockio_bandwidth(
2299 const char *unit,
2300 const char *filename,
2301 unsigned line,
2302 const char *section,
2303 unsigned section_line,
2304 const char *lvalue,
2305 int ltype,
2306 const char *rvalue,
2307 void *data,
2308 void *userdata) {
2309
2310 _cleanup_free_ char *path = NULL;
2311 CGroupBlockIODeviceBandwidth *b;
2312 CGroupContext *c = data;
2313 const char *bandwidth;
2314 off_t bytes;
2315 bool read;
2316 size_t n;
2317 int r;
2318
2319 assert(filename);
2320 assert(lvalue);
2321 assert(rvalue);
2322
2323 read = streq("BlockIOReadBandwidth", lvalue);
2324
2325 if (isempty(rvalue)) {
2326 CGroupBlockIODeviceBandwidth *next;
2327
2328 LIST_FOREACH_SAFE (device_bandwidths, b, next, c->blockio_device_bandwidths)
2329 if (b->read == read)
2330 cgroup_context_free_blockio_device_bandwidth(c, b);
2331
2332 return 0;
2333 }
2334
2335 n = strcspn(rvalue, WHITESPACE);
2336 bandwidth = rvalue + n;
2337 bandwidth += strspn(bandwidth, WHITESPACE);
2338
2339 if (!*bandwidth) {
2340 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2341 "Expected space separated pair of device node and bandwidth. Ignoring.");
2342 return 0;
2343 }
2344
2345 path = strndup(rvalue, n);
2346 if (!path)
2347 return log_oom();
2348
2349 if (!path_startswith(path, "/dev")) {
2350 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2351 "Invalid device node path '%s'. Ignoring.", path);
2352 return 0;
2353 }
2354
2355 r = parse_bytes(bandwidth, &bytes);
2356 if (r < 0 || bytes <= 0) {
2357 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2358 "Block IO Bandwidth '%s' invalid. Ignoring.", rvalue);
2359 return 0;
2360 }
2361
2362 b = new0(CGroupBlockIODeviceBandwidth, 1);
2363 if (!b)
2364 return log_oom();
2365
2366 b->path = path;
2367 path = NULL;
2368 b->bandwidth = (uint64_t) bytes;
2369 b->read = read;
2370
2371 LIST_PREPEND(device_bandwidths, c->blockio_device_bandwidths, b);
2372
2373 return 0;
2374 }
2375
2376 DEFINE_CONFIG_PARSE_ENUM(config_parse_job_mode, job_mode, JobMode, "Failed to parse job mode");
2377
2378 int config_parse_job_mode_isolate(
2379 const char *unit,
2380 const char *filename,
2381 unsigned line,
2382 const char *section,
2383 unsigned section_line,
2384 const char *lvalue,
2385 int ltype,
2386 const char *rvalue,
2387 void *data,
2388 void *userdata) {
2389
2390 JobMode *m = data;
2391 int r;
2392
2393 assert(filename);
2394 assert(lvalue);
2395 assert(rvalue);
2396
2397 r = parse_boolean(rvalue);
2398 if (r < 0) {
2399 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Failed to parse boolean, ignoring: %s", rvalue);
2400 return 0;
2401 }
2402
2403 *m = r ? JOB_ISOLATE : JOB_REPLACE;
2404 return 0;
2405 }
2406
2407 #define FOLLOW_MAX 8
2408
2409 static int open_follow(char **filename, FILE **_f, Set *names, char **_final) {
2410 unsigned c = 0;
2411 int fd, r;
2412 FILE *f;
2413 char *id = NULL;
2414
2415 assert(filename);
2416 assert(*filename);
2417 assert(_f);
2418 assert(names);
2419
2420 /* This will update the filename pointer if the loaded file is
2421 * reached by a symlink. The old string will be freed. */
2422
2423 for (;;) {
2424 char *target, *name;
2425
2426 if (c++ >= FOLLOW_MAX)
2427 return -ELOOP;
2428
2429 path_kill_slashes(*filename);
2430
2431 /* Add the file name we are currently looking at to
2432 * the names of this unit, but only if it is a valid
2433 * unit name. */
2434 name = basename(*filename);
2435
2436 if (unit_name_is_valid(name, TEMPLATE_VALID)) {
2437
2438 id = set_get(names, name);
2439 if (!id) {
2440 id = strdup(name);
2441 if (!id)
2442 return -ENOMEM;
2443
2444 r = set_consume(names, id);
2445 if (r < 0)
2446 return r;
2447 }
2448 }
2449
2450 /* Try to open the file name, but don't if its a symlink */
2451 fd = open(*filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
2452 if (fd >= 0)
2453 break;
2454
2455 if (errno != ELOOP)
2456 return -errno;
2457
2458 /* Hmm, so this is a symlink. Let's read the name, and follow it manually */
2459 r = readlink_and_make_absolute(*filename, &target);
2460 if (r < 0)
2461 return r;
2462
2463 free(*filename);
2464 *filename = target;
2465 }
2466
2467 f = fdopen(fd, "re");
2468 if (!f) {
2469 r = -errno;
2470 close_nointr_nofail(fd);
2471 return r;
2472 }
2473
2474 *_f = f;
2475 *_final = id;
2476 return 0;
2477 }
2478
2479 static int merge_by_names(Unit **u, Set *names, const char *id) {
2480 char *k;
2481 int r;
2482
2483 assert(u);
2484 assert(*u);
2485 assert(names);
2486
2487 /* Let's try to add in all symlink names we found */
2488 while ((k = set_steal_first(names))) {
2489
2490 /* First try to merge in the other name into our
2491 * unit */
2492 r = unit_merge_by_name(*u, k);
2493 if (r < 0) {
2494 Unit *other;
2495
2496 /* Hmm, we couldn't merge the other unit into
2497 * ours? Then let's try it the other way
2498 * round */
2499
2500 other = manager_get_unit((*u)->manager, k);
2501 free(k);
2502
2503 if (other) {
2504 r = unit_merge(other, *u);
2505 if (r >= 0) {
2506 *u = other;
2507 return merge_by_names(u, names, NULL);
2508 }
2509 }
2510
2511 return r;
2512 }
2513
2514 if (id == k)
2515 unit_choose_id(*u, id);
2516
2517 free(k);
2518 }
2519
2520 return 0;
2521 }
2522
2523 static int load_from_path(Unit *u, const char *path) {
2524 int r;
2525 _cleanup_set_free_free_ Set *symlink_names = NULL;
2526 _cleanup_fclose_ FILE *f = NULL;
2527 _cleanup_free_ char *filename = NULL;
2528 char *id = NULL;
2529 Unit *merged;
2530 struct stat st;
2531
2532 assert(u);
2533 assert(path);
2534
2535 symlink_names = set_new(string_hash_func, string_compare_func);
2536 if (!symlink_names)
2537 return -ENOMEM;
2538
2539 if (path_is_absolute(path)) {
2540
2541 filename = strdup(path);
2542 if (!filename)
2543 return -ENOMEM;
2544
2545 r = open_follow(&filename, &f, symlink_names, &id);
2546 if (r < 0) {
2547 free(filename);
2548 filename = NULL;
2549
2550 if (r != -ENOENT)
2551 return r;
2552 }
2553
2554 } else {
2555 char **p;
2556
2557 STRV_FOREACH(p, u->manager->lookup_paths.unit_path) {
2558
2559 /* Instead of opening the path right away, we manually
2560 * follow all symlinks and add their name to our unit
2561 * name set while doing so */
2562 filename = path_make_absolute(path, *p);
2563 if (!filename)
2564 return -ENOMEM;
2565
2566 if (u->manager->unit_path_cache &&
2567 !set_get(u->manager->unit_path_cache, filename))
2568 r = -ENOENT;
2569 else
2570 r = open_follow(&filename, &f, symlink_names, &id);
2571
2572 if (r < 0) {
2573 free(filename);
2574 filename = NULL;
2575
2576 if (r != -ENOENT)
2577 return r;
2578
2579 /* Empty the symlink names for the next run */
2580 set_clear_free(symlink_names);
2581 continue;
2582 }
2583
2584 break;
2585 }
2586 }
2587
2588 if (!filename)
2589 /* Hmm, no suitable file found? */
2590 return 0;
2591
2592 merged = u;
2593 r = merge_by_names(&merged, symlink_names, id);
2594 if (r < 0)
2595 return r;
2596
2597 if (merged != u) {
2598 u->load_state = UNIT_MERGED;
2599 return 0;
2600 }
2601
2602 if (fstat(fileno(f), &st) < 0)
2603 return -errno;
2604
2605 if (null_or_empty(&st))
2606 u->load_state = UNIT_MASKED;
2607 else {
2608 u->load_state = UNIT_LOADED;
2609
2610 /* Now, parse the file contents */
2611 r = config_parse(u->id, filename, f, UNIT_VTABLE(u)->sections,
2612 config_item_perf_lookup,
2613 (void*) load_fragment_gperf_lookup, false, true, u);
2614 if (r < 0)
2615 return r;
2616 }
2617
2618 free(u->fragment_path);
2619 u->fragment_path = filename;
2620 filename = NULL;
2621
2622 u->fragment_mtime = timespec_load(&st.st_mtim);
2623
2624 if (u->source_path) {
2625 if (stat(u->source_path, &st) >= 0)
2626 u->source_mtime = timespec_load(&st.st_mtim);
2627 else
2628 u->source_mtime = 0;
2629 }
2630
2631 return 0;
2632 }
2633
2634 int unit_load_fragment(Unit *u) {
2635 int r;
2636 Iterator i;
2637 const char *t;
2638
2639 assert(u);
2640 assert(u->load_state == UNIT_STUB);
2641 assert(u->id);
2642
2643 /* First, try to find the unit under its id. We always look
2644 * for unit files in the default directories, to make it easy
2645 * to override things by placing things in /etc/systemd/system */
2646 r = load_from_path(u, u->id);
2647 if (r < 0)
2648 return r;
2649
2650 /* Try to find an alias we can load this with */
2651 if (u->load_state == UNIT_STUB)
2652 SET_FOREACH(t, u->names, i) {
2653
2654 if (t == u->id)
2655 continue;
2656
2657 r = load_from_path(u, t);
2658 if (r < 0)
2659 return r;
2660
2661 if (u->load_state != UNIT_STUB)
2662 break;
2663 }
2664
2665 /* And now, try looking for it under the suggested (originally linked) path */
2666 if (u->load_state == UNIT_STUB && u->fragment_path) {
2667
2668 r = load_from_path(u, u->fragment_path);
2669 if (r < 0)
2670 return r;
2671
2672 if (u->load_state == UNIT_STUB) {
2673 /* Hmm, this didn't work? Then let's get rid
2674 * of the fragment path stored for us, so that
2675 * we don't point to an invalid location. */
2676 free(u->fragment_path);
2677 u->fragment_path = NULL;
2678 }
2679 }
2680
2681 /* Look for a template */
2682 if (u->load_state == UNIT_STUB && u->instance) {
2683 _cleanup_free_ char *k;
2684
2685 k = unit_name_template(u->id);
2686 if (!k)
2687 return -ENOMEM;
2688
2689 r = load_from_path(u, k);
2690 if (r < 0)
2691 return r;
2692
2693 if (u->load_state == UNIT_STUB)
2694 SET_FOREACH(t, u->names, i) {
2695 _cleanup_free_ char *z = NULL;
2696
2697 if (t == u->id)
2698 continue;
2699
2700 z = unit_name_template(t);
2701 if (!z)
2702 return -ENOMEM;
2703
2704 r = load_from_path(u, z);
2705 if (r < 0)
2706 return r;
2707
2708 if (u->load_state != UNIT_STUB)
2709 break;
2710 }
2711 }
2712
2713 return 0;
2714 }
2715
2716 void unit_dump_config_items(FILE *f) {
2717 static const struct {
2718 const ConfigParserCallback callback;
2719 const char *rvalue;
2720 } table[] = {
2721 { config_parse_int, "INTEGER" },
2722 { config_parse_unsigned, "UNSIGNED" },
2723 { config_parse_bytes_size, "SIZE" },
2724 { config_parse_bool, "BOOLEAN" },
2725 { config_parse_string, "STRING" },
2726 { config_parse_path, "PATH" },
2727 { config_parse_unit_path_printf, "PATH" },
2728 { config_parse_strv, "STRING [...]" },
2729 { config_parse_exec_nice, "NICE" },
2730 { config_parse_exec_oom_score_adjust, "OOMSCOREADJUST" },
2731 { config_parse_exec_io_class, "IOCLASS" },
2732 { config_parse_exec_io_priority, "IOPRIORITY" },
2733 { config_parse_exec_cpu_sched_policy, "CPUSCHEDPOLICY" },
2734 { config_parse_exec_cpu_sched_prio, "CPUSCHEDPRIO" },
2735 { config_parse_exec_cpu_affinity, "CPUAFFINITY" },
2736 { config_parse_mode, "MODE" },
2737 { config_parse_unit_env_file, "FILE" },
2738 { config_parse_output, "OUTPUT" },
2739 { config_parse_input, "INPUT" },
2740 { config_parse_facility, "FACILITY" },
2741 { config_parse_level, "LEVEL" },
2742 { config_parse_exec_capabilities, "CAPABILITIES" },
2743 { config_parse_exec_secure_bits, "SECUREBITS" },
2744 { config_parse_bounding_set, "BOUNDINGSET" },
2745 { config_parse_limit, "LIMIT" },
2746 { config_parse_unit_deps, "UNIT [...]" },
2747 { config_parse_exec, "PATH [ARGUMENT [...]]" },
2748 { config_parse_service_type, "SERVICETYPE" },
2749 { config_parse_service_restart, "SERVICERESTART" },
2750 #ifdef HAVE_SYSV_COMPAT
2751 { config_parse_sysv_priority, "SYSVPRIORITY" },
2752 #else
2753 { config_parse_warn_compat, "NOTSUPPORTED" },
2754 #endif
2755 { config_parse_kill_mode, "KILLMODE" },
2756 { config_parse_kill_signal, "SIGNAL" },
2757 { config_parse_socket_listen, "SOCKET [...]" },
2758 { config_parse_socket_bind, "SOCKETBIND" },
2759 { config_parse_socket_bindtodevice, "NETWORKINTERFACE" },
2760 { config_parse_sec, "SECONDS" },
2761 { config_parse_nsec, "NANOSECONDS" },
2762 { config_parse_path_strv, "PATH [...]" },
2763 { config_parse_unit_requires_mounts_for, "PATH [...]" },
2764 { config_parse_exec_mount_flags, "MOUNTFLAG [...]" },
2765 { config_parse_unit_string_printf, "STRING" },
2766 { config_parse_trigger_unit, "UNIT" },
2767 { config_parse_timer, "TIMER" },
2768 { config_parse_path_spec, "PATH" },
2769 { config_parse_notify_access, "ACCESS" },
2770 { config_parse_ip_tos, "TOS" },
2771 { config_parse_unit_condition_path, "CONDITION" },
2772 { config_parse_unit_condition_string, "CONDITION" },
2773 { config_parse_unit_condition_null, "CONDITION" },
2774 { config_parse_unit_slice, "SLICE" },
2775 { config_parse_documentation, "URL" },
2776 { config_parse_service_timeout, "SECONDS" },
2777 { config_parse_start_limit_action, "ACTION" },
2778 { config_parse_set_status, "STATUS" },
2779 { config_parse_service_sockets, "SOCKETS" },
2780 { config_parse_environ, "ENVIRON" },
2781 { config_parse_syscall_filter, "SYSCALL" },
2782 { config_parse_cpu_shares, "SHARES" },
2783 { config_parse_memory_limit, "LIMIT" },
2784 { config_parse_device_allow, "DEVICE" },
2785 { config_parse_device_policy, "POLICY" },
2786 { config_parse_blockio_bandwidth, "BANDWIDTH" },
2787 { config_parse_blockio_weight, "WEIGHT" },
2788 { config_parse_blockio_device_weight, "DEVICEWEIGHT" },
2789 { config_parse_long, "LONG" },
2790 { config_parse_socket_service, "SERVICE" },
2791 };
2792
2793 const char *prev = NULL;
2794 const char *i;
2795
2796 assert(f);
2797
2798 NULSTR_FOREACH(i, load_fragment_gperf_nulstr) {
2799 const char *rvalue = "OTHER", *lvalue;
2800 unsigned j;
2801 size_t prefix_len;
2802 const char *dot;
2803 const ConfigPerfItem *p;
2804
2805 assert_se(p = load_fragment_gperf_lookup(i, strlen(i)));
2806
2807 dot = strchr(i, '.');
2808 lvalue = dot ? dot + 1 : i;
2809 prefix_len = dot-i;
2810
2811 if (dot)
2812 if (!prev || !strneq(prev, i, prefix_len+1)) {
2813 if (prev)
2814 fputc('\n', f);
2815
2816 fprintf(f, "[%.*s]\n", (int) prefix_len, i);
2817 }
2818
2819 for (j = 0; j < ELEMENTSOF(table); j++)
2820 if (p->parse == table[j].callback) {
2821 rvalue = table[j].rvalue;
2822 break;
2823 }
2824
2825 fprintf(f, "%s=%s\n", lvalue, rvalue);
2826 prev = i;
2827 }
2828 }
Unnamed repository; edit this file 'description' to name the repository.