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


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