]> 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
tree-wide: drop {} from one-line if blocks
[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 <errno.h>
25 #include <string.h>
26 #include <fcntl.h>
27 #include <sched.h>
28 #include <linux/fs.h>
29 #include <sys/stat.h>
30 #include <sys/resource.h>
31
32 #ifdef HAVE_SECCOMP
33 #include <seccomp.h>
34 #endif
35
36 #include "unit.h"
37 #include "strv.h"
38 #include "conf-parser.h"
39 #include "load-fragment.h"
40 #include "log.h"
41 #include "ioprio.h"
42 #include "securebits.h"
43 #include "missing.h"
44 #include "unit-name.h"
45 #include "unit-printf.h"
46 #include "utf8.h"
47 #include "path-util.h"
48 #include "env-util.h"
49 #include "cgroup.h"
50 #include "bus-util.h"
51 #include "bus-error.h"
52 #include "errno-list.h"
53 #include "af-list.h"
54 #include "cap-list.h"
55 #include "signal-util.h"
56 #include "bus-internal.h"
57
58 #ifdef HAVE_SECCOMP
59 #include "seccomp-util.h"
60 #endif
61
62 int config_parse_warn_compat(
63 const char *unit,
64 const char *filename,
65 unsigned line,
66 const char *section,
67 unsigned section_line,
68 const char *lvalue,
69 int ltype,
70 const char *rvalue,
71 void *data,
72 void *userdata) {
73 Disabled reason = ltype;
74
75 switch(reason) {
76 case DISABLED_CONFIGURATION:
77 log_syntax(unit, LOG_DEBUG, filename, line, EINVAL,
78 "Support for option %s= has been disabled at compile time and it is ignored", lvalue);
79 break;
80 case DISABLED_LEGACY:
81 log_syntax(unit, LOG_INFO, filename, line, EINVAL,
82 "Support for option %s= has been removed and it is ignored", lvalue);
83 break;
84 case DISABLED_EXPERIMENTAL:
85 log_syntax(unit, LOG_INFO, filename, line, EINVAL,
86 "Support for option %s= has not yet been enabled and it is ignored", lvalue);
87 break;
88 };
89
90 return 0;
91 }
92
93 int config_parse_unit_deps(const char *unit,
94 const char *filename,
95 unsigned line,
96 const char *section,
97 unsigned section_line,
98 const char *lvalue,
99 int ltype,
100 const char *rvalue,
101 void *data,
102 void *userdata) {
103
104 UnitDependency d = ltype;
105 Unit *u = userdata;
106 const char *word, *state;
107 size_t l;
108
109 assert(filename);
110 assert(lvalue);
111 assert(rvalue);
112
113 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
114 _cleanup_free_ char *t = NULL, *k = NULL;
115 int r;
116
117 t = strndup(word, l);
118 if (!t)
119 return log_oom();
120
121 r = unit_name_printf(u, t, &k);
122 if (r < 0) {
123 log_syntax(unit, LOG_ERR, filename, line, -r,
124 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
125 continue;
126 }
127
128 r = unit_add_dependency_by_name(u, d, k, NULL, true);
129 if (r < 0)
130 log_syntax(unit, LOG_ERR, filename, line, -r,
131 "Failed to add dependency on %s, ignoring: %s", k, strerror(-r));
132 }
133 if (!isempty(state))
134 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Invalid syntax, ignoring.");
135
136 return 0;
137 }
138
139 int config_parse_unit_string_printf(
140 const char *unit,
141 const char *filename,
142 unsigned line,
143 const char *section,
144 unsigned section_line,
145 const char *lvalue,
146 int ltype,
147 const char *rvalue,
148 void *data,
149 void *userdata) {
150
151 _cleanup_free_ char *k = NULL;
152 Unit *u = userdata;
153 int r;
154
155 assert(filename);
156 assert(lvalue);
157 assert(rvalue);
158 assert(u);
159
160 r = unit_full_printf(u, rvalue, &k);
161 if (r < 0) {
162 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve unit specifiers on %s, ignoring: %m", rvalue);
163 return 0;
164 }
165
166 return config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
167 }
168
169 int config_parse_unit_strv_printf(const char *unit,
170 const char *filename,
171 unsigned line,
172 const char *section,
173 unsigned section_line,
174 const char *lvalue,
175 int ltype,
176 const char *rvalue,
177 void *data,
178 void *userdata) {
179
180 Unit *u = userdata;
181 _cleanup_free_ char *k = NULL;
182 int r;
183
184 assert(filename);
185 assert(lvalue);
186 assert(rvalue);
187 assert(u);
188
189 r = unit_full_printf(u, rvalue, &k);
190 if (r < 0)
191 log_syntax(unit, LOG_ERR, filename, line, -r,
192 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
193
194 return config_parse_strv(unit, filename, line, section, section_line, lvalue, ltype,
195 k ? k : rvalue, data, userdata);
196 }
197
198 int config_parse_unit_path_printf(const char *unit,
199 const char *filename,
200 unsigned line,
201 const char *section,
202 unsigned section_line,
203 const char *lvalue,
204 int ltype,
205 const char *rvalue,
206 void *data,
207 void *userdata) {
208
209 _cleanup_free_ char *k = NULL;
210 Unit *u = userdata;
211 int r;
212
213 assert(filename);
214 assert(lvalue);
215 assert(rvalue);
216 assert(u);
217
218 r = unit_full_printf(u, rvalue, &k);
219 if (r < 0) {
220 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
221 return 0;
222 }
223
224 return config_parse_path(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
225 }
226
227 int config_parse_unit_path_strv_printf(
228 const char *unit,
229 const char *filename,
230 unsigned line,
231 const char *section,
232 unsigned section_line,
233 const char *lvalue,
234 int ltype,
235 const char *rvalue,
236 void *data,
237 void *userdata) {
238
239 char ***x = data;
240 const char *word, *state;
241 Unit *u = userdata;
242 size_t l;
243 int r;
244
245 assert(filename);
246 assert(lvalue);
247 assert(rvalue);
248 assert(u);
249
250 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
251 _cleanup_free_ char *k = NULL;
252 char t[l+1];
253
254 memcpy(t, word, l);
255 t[l] = 0;
256
257 r = unit_full_printf(u, t, &k);
258 if (r < 0) {
259 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve unit specifiers on %s, ignoring: %s", t, strerror(-r));
260 return 0;
261 }
262
263 if (!utf8_is_valid(k)) {
264 log_invalid_utf8(unit, LOG_ERR, filename, line, EINVAL, rvalue);
265 return 0;
266 }
267
268 if (!path_is_absolute(k)) {
269 log_syntax(unit, LOG_ERR, filename, line, -r, "Symlink path %s is not absolute, ignoring: %s", k, strerror(-r));
270 return 0;
271 }
272
273 path_kill_slashes(k);
274
275 r = strv_push(x, k);
276 if (r < 0)
277 return log_oom();
278
279 k = NULL;
280 }
281 if (!isempty(state))
282 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Invalid syntax, ignoring.");
283
284 return 0;
285 }
286
287 int config_parse_socket_listen(const char *unit,
288 const char *filename,
289 unsigned line,
290 const char *section,
291 unsigned section_line,
292 const char *lvalue,
293 int ltype,
294 const char *rvalue,
295 void *data,
296 void *userdata) {
297
298 _cleanup_free_ SocketPort *p = NULL;
299 SocketPort *tail;
300 Socket *s;
301 int r;
302
303 assert(filename);
304 assert(lvalue);
305 assert(rvalue);
306 assert(data);
307
308 s = SOCKET(data);
309
310 if (isempty(rvalue)) {
311 /* An empty assignment removes all ports */
312 socket_free_ports(s);
313 return 0;
314 }
315
316 p = new0(SocketPort, 1);
317 if (!p)
318 return log_oom();
319
320 if (ltype != SOCKET_SOCKET) {
321
322 p->type = ltype;
323 r = unit_full_printf(UNIT(s), rvalue, &p->path);
324 if (r < 0) {
325 p->path = strdup(rvalue);
326 if (!p->path)
327 return log_oom();
328 else
329 log_syntax(unit, LOG_ERR, filename, line, -r,
330 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
331 }
332
333 path_kill_slashes(p->path);
334
335 } else if (streq(lvalue, "ListenNetlink")) {
336 _cleanup_free_ char *k = NULL;
337
338 p->type = SOCKET_SOCKET;
339 r = unit_full_printf(UNIT(s), rvalue, &k);
340 if (r < 0)
341 log_syntax(unit, LOG_ERR, filename, line, -r,
342 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
343
344 r = socket_address_parse_netlink(&p->address, k ?: rvalue);
345 if (r < 0) {
346 log_syntax(unit, LOG_ERR, filename, line, -r,
347 "Failed to parse address value, ignoring: %s", rvalue);
348 return 0;
349 }
350
351 } else {
352 _cleanup_free_ char *k = NULL;
353
354 p->type = SOCKET_SOCKET;
355 r = unit_full_printf(UNIT(s), rvalue, &k);
356 if (r < 0)
357 log_syntax(unit, LOG_ERR, filename, line, -r,
358 "Failed to resolve unit specifiers on %s, ignoring: %s", rvalue, strerror(-r));
359
360 r = socket_address_parse_and_warn(&p->address, k ? k : rvalue);
361 if (r < 0) {
362 log_syntax(unit, LOG_ERR, filename, line, -r,
363 "Failed to parse address value, ignoring: %s", rvalue);
364 return 0;
365 }
366
367 if (streq(lvalue, "ListenStream"))
368 p->address.type = SOCK_STREAM;
369 else if (streq(lvalue, "ListenDatagram"))
370 p->address.type = SOCK_DGRAM;
371 else {
372 assert(streq(lvalue, "ListenSequentialPacket"));
373 p->address.type = SOCK_SEQPACKET;
374 }
375
376 if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {
377 log_syntax(unit, LOG_ERR, filename, line, EOPNOTSUPP,
378 "Address family not supported, ignoring: %s", rvalue);
379 return 0;
380 }
381 }
382
383 p->fd = -1;
384 p->socket = s;
385
386 if (s->ports) {
387 LIST_FIND_TAIL(port, s->ports, tail);
388 LIST_INSERT_AFTER(port, s->ports, tail, p);
389 } else
390 LIST_PREPEND(port, s->ports, p);
391 p = NULL;
392
393 return 0;
394 }
395
396 int config_parse_socket_bind(const char *unit,
397 const char *filename,
398 unsigned line,
399 const char *section,
400 unsigned section_line,
401 const char *lvalue,
402 int ltype,
403 const char *rvalue,
404 void *data,
405 void *userdata) {
406
407 Socket *s;
408 SocketAddressBindIPv6Only b;
409
410 assert(filename);
411 assert(lvalue);
412 assert(rvalue);
413 assert(data);
414
415 s = SOCKET(data);
416
417 b = socket_address_bind_ipv6_only_from_string(rvalue);
418 if (b < 0) {
419 int r;
420
421 r = parse_boolean(rvalue);
422 if (r < 0) {
423 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
424 "Failed to parse bind IPv6 only value, ignoring: %s", rvalue);
425 return 0;
426 }
427
428 s->bind_ipv6_only = r ? SOCKET_ADDRESS_IPV6_ONLY : SOCKET_ADDRESS_BOTH;
429 } else
430 s->bind_ipv6_only = b;
431
432 return 0;
433 }
434
435 int config_parse_exec_nice(const char *unit,
436 const char *filename,
437 unsigned line,
438 const char *section,
439 unsigned section_line,
440 const char *lvalue,
441 int ltype,
442 const char *rvalue,
443 void *data,
444 void *userdata) {
445
446 ExecContext *c = data;
447 int priority, r;
448
449 assert(filename);
450 assert(lvalue);
451 assert(rvalue);
452 assert(data);
453
454 r = safe_atoi(rvalue, &priority);
455 if (r < 0) {
456 log_syntax(unit, LOG_ERR, filename, line, -r,
457 "Failed to parse nice priority, ignoring: %s. ", rvalue);
458 return 0;
459 }
460
461 if (priority < PRIO_MIN || priority >= PRIO_MAX) {
462 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
463 "Nice priority out of range, ignoring: %s", rvalue);
464 return 0;
465 }
466
467 c->nice = priority;
468 c->nice_set = true;
469
470 return 0;
471 }
472
473 int config_parse_exec_oom_score_adjust(const char* unit,
474 const char *filename,
475 unsigned line,
476 const char *section,
477 unsigned section_line,
478 const char *lvalue,
479 int ltype,
480 const char *rvalue,
481 void *data,
482 void *userdata) {
483
484 ExecContext *c = data;
485 int oa, r;
486
487 assert(filename);
488 assert(lvalue);
489 assert(rvalue);
490 assert(data);
491
492 r = safe_atoi(rvalue, &oa);
493 if (r < 0) {
494 log_syntax(unit, LOG_ERR, filename, line, -r,
495 "Failed to parse the OOM score adjust value, ignoring: %s", rvalue);
496 return 0;
497 }
498
499 if (oa < OOM_SCORE_ADJ_MIN || oa > OOM_SCORE_ADJ_MAX) {
500 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
501 "OOM score adjust value out of range, ignoring: %s", rvalue);
502 return 0;
503 }
504
505 c->oom_score_adjust = oa;
506 c->oom_score_adjust_set = true;
507
508 return 0;
509 }
510
511 int config_parse_exec(
512 const char *unit,
513 const char *filename,
514 unsigned line,
515 const char *section,
516 unsigned section_line,
517 const char *lvalue,
518 int ltype,
519 const char *rvalue,
520 void *data,
521 void *userdata) {
522
523 ExecCommand **e = data;
524 const char *p;
525 bool semicolon;
526 int r;
527
528 assert(filename);
529 assert(lvalue);
530 assert(rvalue);
531 assert(e);
532
533 e += ltype;
534
535 rvalue += strspn(rvalue, WHITESPACE);
536 p = rvalue;
537
538 if (isempty(rvalue)) {
539 /* An empty assignment resets the list */
540 *e = exec_command_free_list(*e);
541 return 0;
542 }
543
544 do {
545 int i;
546 _cleanup_strv_free_ char **n = NULL;
547 size_t nlen = 0, nbufsize = 0;
548 _cleanup_free_ ExecCommand *nce = NULL;
549 _cleanup_free_ char *path = NULL, *firstword = NULL;
550 char *f;
551 bool separate_argv0 = false, ignore = false;
552
553 semicolon = false;
554
555 r = extract_first_word_and_warn(&p, &firstword, WHITESPACE, EXTRACT_QUOTES|EXTRACT_CUNESCAPE, unit, filename, line, rvalue);
556 if (r <= 0)
557 return 0;
558
559 f = firstword;
560 for (i = 0; i < 2; i++) {
561 /* We accept an absolute path as first argument, or
562 * alternatively an absolute prefixed with @ to allow
563 * overriding of argv[0]. */
564 if (*f == '-' && !ignore)
565 ignore = true;
566 else if (*f == '@' && !separate_argv0)
567 separate_argv0 = true;
568 else
569 break;
570 f ++;
571 }
572
573 if (isempty(f)) {
574 /* First word is either "-" or "@" with no command. */
575 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
576 "Empty path in command line, ignoring: \"%s\"", rvalue);
577 return 0;
578 }
579
580 if (!string_is_safe(f)) {
581 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
582 "Executable path contains special characters, ignoring: %s", rvalue);
583 return 0;
584 }
585 if (!path_is_absolute(f)) {
586 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
587 "Executable path is not absolute, ignoring: %s", rvalue);
588 return 0;
589 }
590 if (endswith(f, "/")) {
591 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
592 "Executable path specifies a directory, ignoring: %s", rvalue);
593 return 0;
594 }
595
596 if (f == firstword) {
597 path = firstword;
598 firstword = NULL;
599 } else {
600 path = strdup(f);
601 if (!path)
602 return log_oom();
603 }
604
605 if (!separate_argv0) {
606 if (!GREEDY_REALLOC(n, nbufsize, nlen + 2))
607 return log_oom();
608 f = strdup(path);
609 if (!f)
610 return log_oom();
611 n[nlen++] = f;
612 n[nlen] = NULL;
613 }
614
615 path_kill_slashes(path);
616
617 while (!isempty(p)) {
618 _cleanup_free_ char *word = NULL;
619
620 /* Check explicitly for an unquoted semicolon as
621 * command separator token. */
622 if (p[0] == ';' && (!p[1] || strchr(WHITESPACE, p[1]))) {
623 p ++;
624 p += strspn(p, WHITESPACE);
625 semicolon = true;
626 break;
627 }
628
629 /* Check for \; explicitly, to not confuse it with \\;
630 * or "\;" or "\\;" etc. extract_first_word would
631 * return the same for all of those. */
632 if (p[0] == '\\' && p[1] == ';' && (!p[2] || strchr(WHITESPACE, p[2]))) {
633 p += 2;
634 p += strspn(p, WHITESPACE);
635 if (!GREEDY_REALLOC(n, nbufsize, nlen + 2))
636 return log_oom();
637 f = strdup(";");
638 if (!f)
639 return log_oom();
640 n[nlen++] = f;
641 n[nlen] = NULL;
642 continue;
643 }
644
645 r = extract_first_word_and_warn(&p, &word, WHITESPACE, EXTRACT_QUOTES|EXTRACT_CUNESCAPE, unit, filename, line, rvalue);
646 if (r == 0)
647 break;
648 else if (r < 0)
649 return 0;
650
651 if (!GREEDY_REALLOC(n, nbufsize, nlen + 2))
652 return log_oom();
653 n[nlen++] = word;
654 n[nlen] = NULL;
655 word = NULL;
656 }
657
658 if (!n || !n[0]) {
659 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
660 "Empty executable name or zeroeth argument, ignoring: %s", rvalue);
661 return 0;
662 }
663
664 nce = new0(ExecCommand, 1);
665 if (!nce)
666 return log_oom();
667
668 nce->argv = n;
669 nce->path = path;
670 nce->ignore = ignore;
671
672 exec_command_append_list(e, nce);
673
674 /* Do not _cleanup_free_ these. */
675 n = NULL;
676 path = NULL;
677 nce = NULL;
678
679 rvalue = p;
680 } while (semicolon);
681
682 return 0;
683 }
684
685 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type");
686 DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier");
687
688 int config_parse_socket_bindtodevice(const char* unit,
689 const char *filename,
690 unsigned line,
691 const char *section,
692 unsigned section_line,
693 const char *lvalue,
694 int ltype,
695 const char *rvalue,
696 void *data,
697 void *userdata) {
698
699 Socket *s = data;
700 char *n;
701
702 assert(filename);
703 assert(lvalue);
704 assert(rvalue);
705 assert(data);
706
707 if (rvalue[0] && !streq(rvalue, "*")) {
708 n = strdup(rvalue);
709 if (!n)
710 return log_oom();
711 } else
712 n = NULL;
713
714 free(s->bind_to_device);
715 s->bind_to_device = n;
716
717 return 0;
718 }
719
720 DEFINE_CONFIG_PARSE_ENUM(config_parse_output, exec_output, ExecOutput, "Failed to parse output specifier");
721 DEFINE_CONFIG_PARSE_ENUM(config_parse_input, exec_input, ExecInput, "Failed to parse input specifier");
722
723 int config_parse_exec_io_class(const char *unit,
724 const char *filename,
725 unsigned line,
726 const char *section,
727 unsigned section_line,
728 const char *lvalue,
729 int ltype,
730 const char *rvalue,
731 void *data,
732 void *userdata) {
733
734 ExecContext *c = data;
735 int x;
736
737 assert(filename);
738 assert(lvalue);
739 assert(rvalue);
740 assert(data);
741
742 x = ioprio_class_from_string(rvalue);
743 if (x < 0) {
744 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
745 "Failed to parse IO scheduling class, ignoring: %s", rvalue);
746 return 0;
747 }
748
749 c->ioprio = IOPRIO_PRIO_VALUE(x, IOPRIO_PRIO_DATA(c->ioprio));
750 c->ioprio_set = true;
751
752 return 0;
753 }
754
755 int config_parse_exec_io_priority(const char *unit,
756 const char *filename,
757 unsigned line,
758 const char *section,
759 unsigned section_line,
760 const char *lvalue,
761 int ltype,
762 const char *rvalue,
763 void *data,
764 void *userdata) {
765
766 ExecContext *c = data;
767 int i, r;
768
769 assert(filename);
770 assert(lvalue);
771 assert(rvalue);
772 assert(data);
773
774 r = safe_atoi(rvalue, &i);
775 if (r < 0 || i < 0 || i >= IOPRIO_BE_NR) {
776 log_syntax(unit, LOG_ERR, filename, line, -r,
777 "Failed to parse IO priority, ignoring: %s", rvalue);
778 return 0;
779 }
780
781 c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_PRIO_CLASS(c->ioprio), i);
782 c->ioprio_set = true;
783
784 return 0;
785 }
786
787 int config_parse_exec_cpu_sched_policy(const char *unit,
788 const char *filename,
789 unsigned line,
790 const char *section,
791 unsigned section_line,
792 const char *lvalue,
793 int ltype,
794 const char *rvalue,
795 void *data,
796 void *userdata) {
797
798
799 ExecContext *c = data;
800 int x;
801
802 assert(filename);
803 assert(lvalue);
804 assert(rvalue);
805 assert(data);
806
807 x = sched_policy_from_string(rvalue);
808 if (x < 0) {
809 log_syntax(unit, LOG_ERR, filename, line, -x,
810 "Failed to parse CPU scheduling policy, ignoring: %s", rvalue);
811 return 0;
812 }
813
814 c->cpu_sched_policy = x;
815 /* Moving to or from real-time policy? We need to adjust the priority */
816 c->cpu_sched_priority = CLAMP(c->cpu_sched_priority, sched_get_priority_min(x), sched_get_priority_max(x));
817 c->cpu_sched_set = true;
818
819 return 0;
820 }
821
822 int config_parse_exec_cpu_sched_prio(const char *unit,
823 const char *filename,
824 unsigned line,
825 const char *section,
826 unsigned section_line,
827 const char *lvalue,
828 int ltype,
829 const char *rvalue,
830 void *data,
831 void *userdata) {
832
833 ExecContext *c = data;
834 int i, min, max, r;
835
836 assert(filename);
837 assert(lvalue);
838 assert(rvalue);
839 assert(data);
840
841 r = safe_atoi(rvalue, &i);
842 if (r < 0) {
843 log_syntax(unit, LOG_ERR, filename, line, -r,
844 "Failed to parse CPU scheduling policy, ignoring: %s", rvalue);
845 return 0;
846 }
847
848 /* On Linux RR/FIFO range from 1 to 99 and OTHER/BATCH may only be 0 */
849 min = sched_get_priority_min(c->cpu_sched_policy);
850 max = sched_get_priority_max(c->cpu_sched_policy);
851
852 if (i < min || i > max) {
853 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
854 "CPU scheduling priority is out of range, ignoring: %s", rvalue);
855 return 0;
856 }
857
858 c->cpu_sched_priority = i;
859 c->cpu_sched_set = true;
860
861 return 0;
862 }
863
864 int config_parse_exec_cpu_affinity(const char *unit,
865 const char *filename,
866 unsigned line,
867 const char *section,
868 unsigned section_line,
869 const char *lvalue,
870 int ltype,
871 const char *rvalue,
872 void *data,
873 void *userdata) {
874
875 ExecContext *c = data;
876 const char *word, *state;
877 size_t l;
878
879 assert(filename);
880 assert(lvalue);
881 assert(rvalue);
882 assert(data);
883
884 if (isempty(rvalue)) {
885 /* An empty assignment resets the CPU list */
886 if (c->cpuset)
887 CPU_FREE(c->cpuset);
888 c->cpuset = NULL;
889 return 0;
890 }
891
892 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
893 _cleanup_free_ char *t = NULL;
894 int r;
895 unsigned cpu;
896
897 t = strndup(word, l);
898 if (!t)
899 return log_oom();
900
901 r = safe_atou(t, &cpu);
902
903 if (!c->cpuset) {
904 c->cpuset = cpu_set_malloc(&c->cpuset_ncpus);
905 if (!c->cpuset)
906 return log_oom();
907 }
908
909 if (r < 0 || cpu >= c->cpuset_ncpus) {
910 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
911 "Failed to parse CPU affinity '%s', ignoring: %s", t, rvalue);
912 return 0;
913 }
914
915 CPU_SET_S(cpu, CPU_ALLOC_SIZE(c->cpuset_ncpus), c->cpuset);
916 }
917 if (!isempty(state))
918 log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
919 "Trailing garbage, ignoring.");
920
921 return 0;
922 }
923
924 int config_parse_exec_capabilities(const char *unit,
925 const char *filename,
926 unsigned line,
927 const char *section,
928 unsigned section_line,
929 const char *lvalue,
930 int ltype,
931 const char *rvalue,
932 void *data,
933 void *userdata) {
934
935 ExecContext *c = data;
936 cap_t cap;
937
938 assert(filename);
939 assert(lvalue);
940 assert(rvalue);
941 assert(data);
942
943 cap = cap_from_text(rvalue);
944 if (!cap) {
945 log_syntax(unit, LOG_ERR, filename, line, errno,
946 "Failed to parse capabilities, ignoring: %s", rvalue);
947 return 0;
948 }
949
950 if (c->capabilities)
951 cap_free(c->capabilities);
952 c->capabilities = cap;
953
954 return 0;
955 }
956
957 int config_parse_exec_secure_bits(const char *unit,
958 const char *filename,
959 unsigned line,
960 const char *section,
961 unsigned section_line,
962 const char *lvalue,
963 int ltype,
964 const char *rvalue,
965 void *data,
966 void *userdata) {
967
968 ExecContext *c = data;
969 size_t l;
970 const char *word, *state;
971
972 assert(filename);
973 assert(lvalue);
974 assert(rvalue);
975 assert(data);
976
977 if (isempty(rvalue)) {
978 /* An empty assignment resets the field */
979 c->secure_bits = 0;
980 return 0;
981 }
982
983 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
984 if (first_word(word, "keep-caps"))
985 c->secure_bits |= 1<<SECURE_KEEP_CAPS;
986 else if (first_word(word, "keep-caps-locked"))
987 c->secure_bits |= 1<<SECURE_KEEP_CAPS_LOCKED;
988 else if (first_word(word, "no-setuid-fixup"))
989 c->secure_bits |= 1<<SECURE_NO_SETUID_FIXUP;
990 else if (first_word(word, "no-setuid-fixup-locked"))
991 c->secure_bits |= 1<<SECURE_NO_SETUID_FIXUP_LOCKED;
992 else if (first_word(word, "noroot"))
993 c->secure_bits |= 1<<SECURE_NOROOT;
994 else if (first_word(word, "noroot-locked"))
995 c->secure_bits |= 1<<SECURE_NOROOT_LOCKED;
996 else {
997 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
998 "Failed to parse secure bits, ignoring: %s", rvalue);
999 return 0;
1000 }
1001 }
1002 if (!isempty(state))
1003 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1004 "Invalid syntax, garbage at the end, ignoring.");
1005
1006 return 0;
1007 }
1008
1009 int config_parse_bounding_set(const char *unit,
1010 const char *filename,
1011 unsigned line,
1012 const char *section,
1013 unsigned section_line,
1014 const char *lvalue,
1015 int ltype,
1016 const char *rvalue,
1017 void *data,
1018 void *userdata) {
1019
1020 uint64_t *capability_bounding_set_drop = data;
1021 const char *word, *state;
1022 size_t l;
1023 bool invert = false;
1024 uint64_t sum = 0;
1025
1026 assert(filename);
1027 assert(lvalue);
1028 assert(rvalue);
1029 assert(data);
1030
1031 if (rvalue[0] == '~') {
1032 invert = true;
1033 rvalue++;
1034 }
1035
1036 /* Note that we store this inverted internally, since the
1037 * kernel wants it like this. But we actually expose it
1038 * non-inverted everywhere to have a fully normalized
1039 * interface. */
1040
1041 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
1042 _cleanup_free_ char *t = NULL;
1043 int cap;
1044
1045 t = strndup(word, l);
1046 if (!t)
1047 return log_oom();
1048
1049 cap = capability_from_name(t);
1050 if (cap < 0) {
1051 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Failed to parse capability in bounding set, ignoring: %s", t);
1052 continue;
1053 }
1054
1055 sum |= ((uint64_t) 1ULL) << (uint64_t) cap;
1056 }
1057 if (!isempty(state))
1058 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1059 "Trailing garbage, ignoring.");
1060
1061 if (invert)
1062 *capability_bounding_set_drop |= sum;
1063 else
1064 *capability_bounding_set_drop |= ~sum;
1065
1066 return 0;
1067 }
1068
1069 int config_parse_limit(const char *unit,
1070 const char *filename,
1071 unsigned line,
1072 const char *section,
1073 unsigned section_line,
1074 const char *lvalue,
1075 int ltype,
1076 const char *rvalue,
1077 void *data,
1078 void *userdata) {
1079
1080 struct rlimit **rl = data;
1081 unsigned long long u;
1082
1083 assert(filename);
1084 assert(lvalue);
1085 assert(rvalue);
1086 assert(data);
1087
1088 rl += ltype;
1089
1090 if (streq(rvalue, "infinity"))
1091 u = (unsigned long long) RLIM_INFINITY;
1092 else {
1093 int r;
1094
1095 r = safe_atollu(rvalue, &u);
1096 if (r < 0) {
1097 log_syntax(unit, LOG_ERR, filename, line, -r,
1098 "Failed to parse resource value, ignoring: %s", rvalue);
1099 return 0;
1100 }
1101 }
1102
1103 if (!*rl) {
1104 *rl = new(struct rlimit, 1);
1105 if (!*rl)
1106 return log_oom();
1107 }
1108
1109 (*rl)->rlim_cur = (*rl)->rlim_max = (rlim_t) u;
1110 return 0;
1111 }
1112
1113 #ifdef HAVE_SYSV_COMPAT
1114 int config_parse_sysv_priority(const char *unit,
1115 const char *filename,
1116 unsigned line,
1117 const char *section,
1118 unsigned section_line,
1119 const char *lvalue,
1120 int ltype,
1121 const char *rvalue,
1122 void *data,
1123 void *userdata) {
1124
1125 int *priority = data;
1126 int i, r;
1127
1128 assert(filename);
1129 assert(lvalue);
1130 assert(rvalue);
1131 assert(data);
1132
1133 r = safe_atoi(rvalue, &i);
1134 if (r < 0 || i < 0) {
1135 log_syntax(unit, LOG_ERR, filename, line, -r,
1136 "Failed to parse SysV start priority, ignoring: %s", rvalue);
1137 return 0;
1138 }
1139
1140 *priority = (int) i;
1141 return 0;
1142 }
1143 #endif
1144
1145 DEFINE_CONFIG_PARSE_ENUM(config_parse_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode, "Failed to parse utmp mode");
1146 DEFINE_CONFIG_PARSE_ENUM(config_parse_kill_mode, kill_mode, KillMode, "Failed to parse kill mode");
1147
1148 int config_parse_exec_mount_flags(const char *unit,
1149 const char *filename,
1150 unsigned line,
1151 const char *section,
1152 unsigned section_line,
1153 const char *lvalue,
1154 int ltype,
1155 const char *rvalue,
1156 void *data,
1157 void *userdata) {
1158
1159 ExecContext *c = data;
1160 const char *word, *state;
1161 size_t l;
1162 unsigned long flags = 0;
1163
1164 assert(filename);
1165 assert(lvalue);
1166 assert(rvalue);
1167 assert(data);
1168
1169 FOREACH_WORD_SEPARATOR(word, l, rvalue, ", ", state) {
1170 _cleanup_free_ char *t;
1171
1172 t = strndup(word, l);
1173 if (!t)
1174 return log_oom();
1175
1176 if (streq(t, "shared"))
1177 flags = MS_SHARED;
1178 else if (streq(t, "slave"))
1179 flags = MS_SLAVE;
1180 else if (streq(t, "private"))
1181 flags = MS_PRIVATE;
1182 else {
1183 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Failed to parse mount flag %s, ignoring: %s", t, rvalue);
1184 return 0;
1185 }
1186 }
1187 if (!isempty(state))
1188 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Trailing garbage, ignoring.");
1189
1190 c->mount_flags = flags;
1191 return 0;
1192 }
1193
1194 int config_parse_exec_selinux_context(
1195 const char *unit,
1196 const char *filename,
1197 unsigned line,
1198 const char *section,
1199 unsigned section_line,
1200 const char *lvalue,
1201 int ltype,
1202 const char *rvalue,
1203 void *data,
1204 void *userdata) {
1205
1206 ExecContext *c = data;
1207 Unit *u = userdata;
1208 bool ignore;
1209 char *k;
1210 int r;
1211
1212 assert(filename);
1213 assert(lvalue);
1214 assert(rvalue);
1215 assert(data);
1216
1217 if (isempty(rvalue)) {
1218 c->selinux_context = mfree(c->selinux_context);
1219 c->selinux_context_ignore = false;
1220 return 0;
1221 }
1222
1223 if (rvalue[0] == '-') {
1224 ignore = true;
1225 rvalue++;
1226 } else
1227 ignore = false;
1228
1229 r = unit_name_printf(u, rvalue, &k);
1230 if (r < 0) {
1231 log_syntax(unit, LOG_ERR, filename, line, -r,
1232 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
1233 return 0;
1234 }
1235
1236 free(c->selinux_context);
1237 c->selinux_context = k;
1238 c->selinux_context_ignore = ignore;
1239
1240 return 0;
1241 }
1242
1243 int config_parse_exec_apparmor_profile(
1244 const char *unit,
1245 const char *filename,
1246 unsigned line,
1247 const char *section,
1248 unsigned section_line,
1249 const char *lvalue,
1250 int ltype,
1251 const char *rvalue,
1252 void *data,
1253 void *userdata) {
1254
1255 ExecContext *c = data;
1256 Unit *u = userdata;
1257 bool ignore;
1258 char *k;
1259 int r;
1260
1261 assert(filename);
1262 assert(lvalue);
1263 assert(rvalue);
1264 assert(data);
1265
1266 if (isempty(rvalue)) {
1267 c->apparmor_profile = mfree(c->apparmor_profile);
1268 c->apparmor_profile_ignore = false;
1269 return 0;
1270 }
1271
1272 if (rvalue[0] == '-') {
1273 ignore = true;
1274 rvalue++;
1275 } else
1276 ignore = false;
1277
1278 r = unit_name_printf(u, rvalue, &k);
1279 if (r < 0) {
1280 log_syntax(unit, LOG_ERR, filename, line, -r,
1281 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
1282 return 0;
1283 }
1284
1285 free(c->apparmor_profile);
1286 c->apparmor_profile = k;
1287 c->apparmor_profile_ignore = ignore;
1288
1289 return 0;
1290 }
1291
1292 int config_parse_exec_smack_process_label(
1293 const char *unit,
1294 const char *filename,
1295 unsigned line,
1296 const char *section,
1297 unsigned section_line,
1298 const char *lvalue,
1299 int ltype,
1300 const char *rvalue,
1301 void *data,
1302 void *userdata) {
1303
1304 ExecContext *c = data;
1305 Unit *u = userdata;
1306 bool ignore;
1307 char *k;
1308 int r;
1309
1310 assert(filename);
1311 assert(lvalue);
1312 assert(rvalue);
1313 assert(data);
1314
1315 if (isempty(rvalue)) {
1316 c->smack_process_label = mfree(c->smack_process_label);
1317 c->smack_process_label_ignore = false;
1318 return 0;
1319 }
1320
1321 if (rvalue[0] == '-') {
1322 ignore = true;
1323 rvalue++;
1324 } else
1325 ignore = false;
1326
1327 r = unit_name_printf(u, rvalue, &k);
1328 if (r < 0) {
1329 log_syntax(unit, LOG_ERR, filename, line, -r,
1330 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
1331 return 0;
1332 }
1333
1334 free(c->smack_process_label);
1335 c->smack_process_label = k;
1336 c->smack_process_label_ignore = ignore;
1337
1338 return 0;
1339 }
1340
1341 int config_parse_timer(const char *unit,
1342 const char *filename,
1343 unsigned line,
1344 const char *section,
1345 unsigned section_line,
1346 const char *lvalue,
1347 int ltype,
1348 const char *rvalue,
1349 void *data,
1350 void *userdata) {
1351
1352 Timer *t = data;
1353 usec_t u = 0;
1354 TimerValue *v;
1355 TimerBase b;
1356 CalendarSpec *c = NULL;
1357
1358 assert(filename);
1359 assert(lvalue);
1360 assert(rvalue);
1361 assert(data);
1362
1363 if (isempty(rvalue)) {
1364 /* Empty assignment resets list */
1365 timer_free_values(t);
1366 return 0;
1367 }
1368
1369 b = timer_base_from_string(lvalue);
1370 if (b < 0) {
1371 log_syntax(unit, LOG_ERR, filename, line, -b,
1372 "Failed to parse timer base, ignoring: %s", lvalue);
1373 return 0;
1374 }
1375
1376 if (b == TIMER_CALENDAR) {
1377 if (calendar_spec_from_string(rvalue, &c) < 0) {
1378 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1379 "Failed to parse calendar specification, ignoring: %s",
1380 rvalue);
1381 return 0;
1382 }
1383 } else {
1384 if (parse_sec(rvalue, &u) < 0) {
1385 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1386 "Failed to parse timer value, ignoring: %s",
1387 rvalue);
1388 return 0;
1389 }
1390 }
1391
1392 v = new0(TimerValue, 1);
1393 if (!v) {
1394 calendar_spec_free(c);
1395 return log_oom();
1396 }
1397
1398 v->base = b;
1399 v->value = u;
1400 v->calendar_spec = c;
1401
1402 LIST_PREPEND(value, t->values, v);
1403
1404 return 0;
1405 }
1406
1407 int config_parse_trigger_unit(
1408 const char *unit,
1409 const char *filename,
1410 unsigned line,
1411 const char *section,
1412 unsigned section_line,
1413 const char *lvalue,
1414 int ltype,
1415 const char *rvalue,
1416 void *data,
1417 void *userdata) {
1418
1419 _cleanup_free_ char *p = NULL;
1420 Unit *u = data;
1421 UnitType type;
1422 int r;
1423
1424 assert(filename);
1425 assert(lvalue);
1426 assert(rvalue);
1427 assert(data);
1428
1429 if (!set_isempty(u->dependencies[UNIT_TRIGGERS])) {
1430 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1431 "Multiple units to trigger specified, ignoring: %s", rvalue);
1432 return 0;
1433 }
1434
1435 r = unit_name_printf(u, rvalue, &p);
1436 if (r < 0)
1437 log_syntax(unit, LOG_ERR, filename, line, -r,
1438 "Failed to resolve specifiers, ignoring: %s", strerror(-r));
1439
1440 type = unit_name_to_type(p ?: rvalue);
1441 if (type < 0) {
1442 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1443 "Unit type not valid, ignoring: %s", rvalue);
1444 return 0;
1445 }
1446
1447 if (type == u->type) {
1448 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1449 "Trigger cannot be of same type, ignoring: %s", rvalue);
1450 return 0;
1451 }
1452
1453 r = unit_add_two_dependencies_by_name(u, UNIT_BEFORE, UNIT_TRIGGERS, p ?: rvalue, NULL, true);
1454 if (r < 0) {
1455 log_syntax(unit, LOG_ERR, filename, line, -r,
1456 "Failed to add trigger on %s, ignoring: %s", p ?: rvalue, strerror(-r));
1457 return 0;
1458 }
1459
1460 return 0;
1461 }
1462
1463 int config_parse_path_spec(const char *unit,
1464 const char *filename,
1465 unsigned line,
1466 const char *section,
1467 unsigned section_line,
1468 const char *lvalue,
1469 int ltype,
1470 const char *rvalue,
1471 void *data,
1472 void *userdata) {
1473
1474 Path *p = data;
1475 PathSpec *s;
1476 PathType b;
1477 _cleanup_free_ char *k = NULL;
1478 int r;
1479
1480 assert(filename);
1481 assert(lvalue);
1482 assert(rvalue);
1483 assert(data);
1484
1485 if (isempty(rvalue)) {
1486 /* Empty assignment clears list */
1487 path_free_specs(p);
1488 return 0;
1489 }
1490
1491 b = path_type_from_string(lvalue);
1492 if (b < 0) {
1493 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1494 "Failed to parse path type, ignoring: %s", lvalue);
1495 return 0;
1496 }
1497
1498 r = unit_full_printf(UNIT(p), rvalue, &k);
1499 if (r < 0) {
1500 k = strdup(rvalue);
1501 if (!k)
1502 return log_oom();
1503 else
1504 log_syntax(unit, LOG_ERR, filename, line, -r,
1505 "Failed to resolve unit specifiers on %s. Ignoring.",
1506 rvalue);
1507 }
1508
1509 if (!path_is_absolute(k)) {
1510 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1511 "Path is not absolute, ignoring: %s", k);
1512 return 0;
1513 }
1514
1515 s = new0(PathSpec, 1);
1516 if (!s)
1517 return log_oom();
1518
1519 s->unit = UNIT(p);
1520 s->path = path_kill_slashes(k);
1521 k = NULL;
1522 s->type = b;
1523 s->inotify_fd = -1;
1524
1525 LIST_PREPEND(spec, p->specs, s);
1526
1527 return 0;
1528 }
1529
1530 int config_parse_socket_service(
1531 const char *unit,
1532 const char *filename,
1533 unsigned line,
1534 const char *section,
1535 unsigned section_line,
1536 const char *lvalue,
1537 int ltype,
1538 const char *rvalue,
1539 void *data,
1540 void *userdata) {
1541
1542 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1543 Socket *s = data;
1544 int r;
1545 Unit *x;
1546 _cleanup_free_ char *p = NULL;
1547
1548 assert(filename);
1549 assert(lvalue);
1550 assert(rvalue);
1551 assert(data);
1552
1553 r = unit_name_printf(UNIT(s), rvalue, &p);
1554 if (r < 0) {
1555 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve specifiers, ignoring: %s", rvalue);
1556 return 0;
1557 }
1558
1559 if (!endswith(p, ".service")) {
1560 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Unit must be of type service, ignoring: %s", rvalue);
1561 return 0;
1562 }
1563
1564 r = manager_load_unit(UNIT(s)->manager, p, NULL, &error, &x);
1565 if (r < 0) {
1566 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to load unit %s, ignoring: %s", rvalue, bus_error_message(&error, r));
1567 return 0;
1568 }
1569
1570 unit_ref_set(&s->service, x);
1571
1572 return 0;
1573 }
1574
1575 int config_parse_service_sockets(
1576 const char *unit,
1577 const char *filename,
1578 unsigned line,
1579 const char *section,
1580 unsigned section_line,
1581 const char *lvalue,
1582 int ltype,
1583 const char *rvalue,
1584 void *data,
1585 void *userdata) {
1586
1587 Service *s = data;
1588 const char *word, *state;
1589 size_t l;
1590 int r;
1591
1592 assert(filename);
1593 assert(lvalue);
1594 assert(rvalue);
1595 assert(data);
1596
1597 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
1598 _cleanup_free_ char *t = NULL, *k = NULL;
1599
1600 t = strndup(word, l);
1601 if (!t)
1602 return log_oom();
1603
1604 r = unit_name_printf(UNIT(s), t, &k);
1605 if (r < 0) {
1606 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve specifiers, ignoring: %m");
1607 continue;
1608 }
1609
1610 if (!endswith(k, ".socket")) {
1611 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Unit must be of type socket, ignoring: %s", k);
1612 continue;
1613 }
1614
1615 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_WANTS, UNIT_AFTER, k, NULL, true);
1616 if (r < 0)
1617 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to add dependency on %s, ignoring: %m", k);
1618
1619 r = unit_add_dependency_by_name(UNIT(s), UNIT_TRIGGERED_BY, k, NULL, true);
1620 if (r < 0)
1621 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to add dependency on %s, ignoring: %m", k);
1622 }
1623 if (!isempty(state))
1624 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Trailing garbage, ignoring.");
1625
1626 return 0;
1627 }
1628
1629 int config_parse_bus_name(
1630 const char *unit,
1631 const char *filename,
1632 unsigned line,
1633 const char *section,
1634 unsigned section_line,
1635 const char *lvalue,
1636 int ltype,
1637 const char *rvalue,
1638 void *data,
1639 void *userdata) {
1640
1641 _cleanup_free_ char *k = NULL;
1642 Unit *u = userdata;
1643 int r;
1644
1645 assert(filename);
1646 assert(lvalue);
1647 assert(rvalue);
1648 assert(u);
1649
1650 r = unit_full_printf(u, rvalue, &k);
1651 if (r < 0) {
1652 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve unit specifiers on %s, ignoring: %m", rvalue);
1653 return 0;
1654 }
1655
1656 if (!service_name_is_valid(k)) {
1657 log_syntax(unit, LOG_ERR, filename, line, r, "Invalid bus name %s, ignoring.", k);
1658 return 0;
1659 }
1660
1661 return config_parse_string(unit, filename, line, section, section_line, lvalue, ltype, k, data, userdata);
1662 }
1663
1664 int config_parse_service_timeout(const char *unit,
1665 const char *filename,
1666 unsigned line,
1667 const char *section,
1668 unsigned section_line,
1669 const char *lvalue,
1670 int ltype,
1671 const char *rvalue,
1672 void *data,
1673 void *userdata) {
1674
1675 Service *s = userdata;
1676 int r;
1677
1678 assert(filename);
1679 assert(lvalue);
1680 assert(rvalue);
1681 assert(s);
1682
1683 r = config_parse_sec(unit, filename, line, section, section_line, lvalue, ltype,
1684 rvalue, data, userdata);
1685 if (r < 0)
1686 return r;
1687
1688 if (streq(lvalue, "TimeoutSec")) {
1689 s->start_timeout_defined = true;
1690 s->timeout_stop_usec = s->timeout_start_usec;
1691 } else if (streq(lvalue, "TimeoutStartSec"))
1692 s->start_timeout_defined = true;
1693
1694 return 0;
1695 }
1696
1697 int config_parse_busname_service(
1698 const char *unit,
1699 const char *filename,
1700 unsigned line,
1701 const char *section,
1702 unsigned section_line,
1703 const char *lvalue,
1704 int ltype,
1705 const char *rvalue,
1706 void *data,
1707 void *userdata) {
1708
1709 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1710 BusName *n = data;
1711 int r;
1712 Unit *x;
1713 _cleanup_free_ char *p = NULL;
1714
1715 assert(filename);
1716 assert(lvalue);
1717 assert(rvalue);
1718 assert(data);
1719
1720 r = unit_name_printf(UNIT(n), rvalue, &p);
1721 if (r < 0) {
1722 log_syntax(unit, LOG_ERR, filename, line, -r,
1723 "Failed to resolve specifiers, ignoring: %s", rvalue);
1724 return 0;
1725 }
1726
1727 if (!endswith(p, ".service")) {
1728 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1729 "Unit must be of type service, ignoring: %s", rvalue);
1730 return 0;
1731 }
1732
1733 r = manager_load_unit(UNIT(n)->manager, p, NULL, &error, &x);
1734 if (r < 0) {
1735 log_syntax(unit, LOG_ERR, filename, line, -r,
1736 "Failed to load unit %s, ignoring: %s", rvalue, bus_error_message(&error, r));
1737 return 0;
1738 }
1739
1740 unit_ref_set(&n->service, x);
1741
1742 return 0;
1743 }
1744
1745 DEFINE_CONFIG_PARSE_ENUM(config_parse_bus_policy_world, bus_policy_access, BusPolicyAccess, "Failed to parse bus name policy access");
1746
1747 int config_parse_bus_policy(
1748 const char *unit,
1749 const char *filename,
1750 unsigned line,
1751 const char *section,
1752 unsigned section_line,
1753 const char *lvalue,
1754 int ltype,
1755 const char *rvalue,
1756 void *data,
1757 void *userdata) {
1758
1759 _cleanup_free_ BusNamePolicy *p = NULL;
1760 _cleanup_free_ char *id_str = NULL;
1761 BusName *busname = data;
1762 char *access_str;
1763
1764 assert(filename);
1765 assert(lvalue);
1766 assert(rvalue);
1767 assert(data);
1768
1769 p = new0(BusNamePolicy, 1);
1770 if (!p)
1771 return log_oom();
1772
1773 if (streq(lvalue, "AllowUser"))
1774 p->type = BUSNAME_POLICY_TYPE_USER;
1775 else if (streq(lvalue, "AllowGroup"))
1776 p->type = BUSNAME_POLICY_TYPE_GROUP;
1777 else
1778 assert_not_reached("Unknown lvalue");
1779
1780 id_str = strdup(rvalue);
1781 if (!id_str)
1782 return log_oom();
1783
1784 access_str = strpbrk(id_str, WHITESPACE);
1785 if (!access_str) {
1786 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1787 "Invalid busname policy value '%s'", rvalue);
1788 return 0;
1789 }
1790
1791 *access_str = '\0';
1792 access_str++;
1793 access_str += strspn(access_str, WHITESPACE);
1794
1795 p->access = bus_policy_access_from_string(access_str);
1796 if (p->access < 0) {
1797 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1798 "Invalid busname policy access type '%s'", access_str);
1799 return 0;
1800 }
1801
1802 p->name = id_str;
1803 id_str = NULL;
1804
1805 LIST_PREPEND(policy, busname->policy, p);
1806 p = NULL;
1807
1808 return 0;
1809 }
1810
1811 int config_parse_bus_endpoint_policy(
1812 const char *unit,
1813 const char *filename,
1814 unsigned line,
1815 const char *section,
1816 unsigned section_line,
1817 const char *lvalue,
1818 int ltype,
1819 const char *rvalue,
1820 void *data,
1821 void *userdata) {
1822
1823 _cleanup_free_ char *name = NULL;
1824 BusPolicyAccess access;
1825 ExecContext *c = data;
1826 char *access_str;
1827 int r;
1828
1829 assert(filename);
1830 assert(lvalue);
1831 assert(rvalue);
1832 assert(data);
1833
1834 name = strdup(rvalue);
1835 if (!name)
1836 return log_oom();
1837
1838 access_str = strpbrk(name, WHITESPACE);
1839 if (!access_str) {
1840 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1841 "Invalid endpoint policy value '%s'", rvalue);
1842 return 0;
1843 }
1844
1845 *access_str = '\0';
1846 access_str++;
1847 access_str += strspn(access_str, WHITESPACE);
1848
1849 access = bus_policy_access_from_string(access_str);
1850 if (access <= _BUS_POLICY_ACCESS_INVALID ||
1851 access >= _BUS_POLICY_ACCESS_MAX) {
1852 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1853 "Invalid endpoint policy access type '%s'", access_str);
1854 return 0;
1855 }
1856
1857 if (!c->bus_endpoint) {
1858 r = bus_endpoint_new(&c->bus_endpoint);
1859
1860 if (r < 0)
1861 return r;
1862 }
1863
1864 return bus_endpoint_add_policy(c->bus_endpoint, name, access);
1865 }
1866
1867 int config_parse_unit_env_file(const char *unit,
1868 const char *filename,
1869 unsigned line,
1870 const char *section,
1871 unsigned section_line,
1872 const char *lvalue,
1873 int ltype,
1874 const char *rvalue,
1875 void *data,
1876 void *userdata) {
1877
1878 char ***env = data;
1879 Unit *u = userdata;
1880 _cleanup_free_ char *n = NULL;
1881 const char *s;
1882 int r;
1883
1884 assert(filename);
1885 assert(lvalue);
1886 assert(rvalue);
1887 assert(data);
1888
1889 if (isempty(rvalue)) {
1890 /* Empty assignment frees the list */
1891 strv_free(*env);
1892 *env = NULL;
1893 return 0;
1894 }
1895
1896 r = unit_full_printf(u, rvalue, &n);
1897 if (r < 0)
1898 log_syntax(unit, LOG_ERR, filename, line, -r,
1899 "Failed to resolve specifiers, ignoring: %s", rvalue);
1900
1901 s = n ?: rvalue;
1902 if (!path_is_absolute(s[0] == '-' ? s + 1 : s)) {
1903 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1904 "Path '%s' is not absolute, ignoring.", s);
1905 return 0;
1906 }
1907
1908 r = strv_extend(env, s);
1909 if (r < 0)
1910 return log_oom();
1911
1912 return 0;
1913 }
1914
1915 int config_parse_environ(const char *unit,
1916 const char *filename,
1917 unsigned line,
1918 const char *section,
1919 unsigned section_line,
1920 const char *lvalue,
1921 int ltype,
1922 const char *rvalue,
1923 void *data,
1924 void *userdata) {
1925
1926 Unit *u = userdata;
1927 char*** env = data;
1928 const char *word, *state;
1929 size_t l;
1930 _cleanup_free_ char *k = NULL;
1931 int r;
1932
1933 assert(filename);
1934 assert(lvalue);
1935 assert(rvalue);
1936 assert(data);
1937
1938 if (isempty(rvalue)) {
1939 /* Empty assignment resets the list */
1940 strv_free(*env);
1941 *env = NULL;
1942 return 0;
1943 }
1944
1945 if (u) {
1946 r = unit_full_printf(u, rvalue, &k);
1947 if (r < 0)
1948 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve specifiers, ignoring: %s", rvalue);
1949 }
1950
1951 if (!k)
1952 k = strdup(rvalue);
1953 if (!k)
1954 return log_oom();
1955
1956 FOREACH_WORD_QUOTED(word, l, k, state) {
1957 _cleanup_free_ char *n = NULL;
1958 char **x;
1959
1960 r = cunescape_length(word, l, 0, &n);
1961 if (r < 0) {
1962 log_syntax(unit, LOG_ERR, filename, line, r, "Couldn't unescape assignment, ignoring: %s", rvalue);
1963 continue;
1964 }
1965
1966 if (!env_assignment_is_valid(n)) {
1967 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Invalid environment assignment, ignoring: %s", rvalue);
1968 continue;
1969 }
1970
1971 x = strv_env_set(*env, n);
1972 if (!x)
1973 return log_oom();
1974
1975 strv_free(*env);
1976 *env = x;
1977 }
1978 if (!isempty(state))
1979 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
1980 "Trailing garbage, ignoring.");
1981
1982 return 0;
1983 }
1984
1985 int config_parse_ip_tos(const char *unit,
1986 const char *filename,
1987 unsigned line,
1988 const char *section,
1989 unsigned section_line,
1990 const char *lvalue,
1991 int ltype,
1992 const char *rvalue,
1993 void *data,
1994 void *userdata) {
1995
1996 int *ip_tos = data, x;
1997
1998 assert(filename);
1999 assert(lvalue);
2000 assert(rvalue);
2001 assert(data);
2002
2003 x = ip_tos_from_string(rvalue);
2004 if (x < 0) {
2005 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2006 "Failed to parse IP TOS value, ignoring: %s", rvalue);
2007 return 0;
2008 }
2009
2010 *ip_tos = x;
2011 return 0;
2012 }
2013
2014 int config_parse_unit_condition_path(
2015 const char *unit,
2016 const char *filename,
2017 unsigned line,
2018 const char *section,
2019 unsigned section_line,
2020 const char *lvalue,
2021 int ltype,
2022 const char *rvalue,
2023 void *data,
2024 void *userdata) {
2025
2026 _cleanup_free_ char *p = NULL;
2027 Condition **list = data, *c;
2028 ConditionType t = ltype;
2029 bool trigger, negate;
2030 Unit *u = userdata;
2031 int r;
2032
2033 assert(filename);
2034 assert(lvalue);
2035 assert(rvalue);
2036 assert(data);
2037
2038 if (isempty(rvalue)) {
2039 /* Empty assignment resets the list */
2040 *list = condition_free_list(*list);
2041 return 0;
2042 }
2043
2044 trigger = rvalue[0] == '|';
2045 if (trigger)
2046 rvalue++;
2047
2048 negate = rvalue[0] == '!';
2049 if (negate)
2050 rvalue++;
2051
2052 r = unit_full_printf(u, rvalue, &p);
2053 if (r < 0) {
2054 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve specifiers, ignoring: %s", rvalue);
2055 return 0;
2056 }
2057
2058 if (!path_is_absolute(p)) {
2059 log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Path in condition not absolute, ignoring: %s", p);
2060 return 0;
2061 }
2062
2063 c = condition_new(t, p, trigger, negate);
2064 if (!c)
2065 return log_oom();
2066
2067 LIST_PREPEND(conditions, *list, c);
2068 return 0;
2069 }
2070
2071 int config_parse_unit_condition_string(
2072 const char *unit,
2073 const char *filename,
2074 unsigned line,
2075 const char *section,
2076 unsigned section_line,
2077 const char *lvalue,
2078 int ltype,
2079 const char *rvalue,
2080 void *data,
2081 void *userdata) {
2082
2083 _cleanup_free_ char *s = NULL;
2084 Condition **list = data, *c;
2085 ConditionType t = ltype;
2086 bool trigger, negate;
2087 Unit *u = userdata;
2088 int r;
2089
2090 assert(filename);
2091 assert(lvalue);
2092 assert(rvalue);
2093 assert(data);
2094
2095 if (isempty(rvalue)) {
2096 /* Empty assignment resets the list */
2097 *list = condition_free_list(*list);
2098 return 0;
2099 }
2100
2101 trigger = rvalue[0] == '|';
2102 if (trigger)
2103 rvalue++;
2104
2105 negate = rvalue[0] == '!';
2106 if (negate)
2107 rvalue++;
2108
2109 r = unit_full_printf(u, rvalue, &s);
2110 if (r < 0) {
2111 log_syntax(unit, LOG_ERR, filename, line, -r, "Failed to resolve specifiers, ignoring: %s", rvalue);
2112 return 0;
2113 }
2114
2115 c = condition_new(t, s, trigger, negate);
2116 if (!c)
2117 return log_oom();
2118
2119 LIST_PREPEND(conditions, *list, c);
2120 return 0;
2121 }
2122
2123 int config_parse_unit_condition_null(
2124 const char *unit,
2125 const char *filename,
2126 unsigned line,
2127 const char *section,
2128 unsigned section_line,
2129 const char *lvalue,
2130 int ltype,
2131 const char *rvalue,
2132 void *data,
2133 void *userdata) {
2134
2135 Condition **list = data, *c;
2136 bool trigger, negate;
2137 int b;
2138
2139 assert(filename);
2140 assert(lvalue);
2141 assert(rvalue);
2142 assert(data);
2143
2144 if (isempty(rvalue)) {
2145 /* Empty assignment resets the list */
2146 *list = condition_free_list(*list);
2147 return 0;
2148 }
2149
2150 trigger = rvalue[0] == '|';
2151 if (trigger)
2152 rvalue++;
2153
2154 negate = rvalue[0] == '!';
2155 if (negate)
2156 rvalue++;
2157
2158 b = parse_boolean(rvalue);
2159 if (b < 0) {
2160 log_syntax(unit, LOG_ERR, filename, line, -b, "Failed to parse boolean value in condition, ignoring: %s", rvalue);
2161 return 0;
2162 }
2163
2164 if (!b)
2165 negate = !negate;
2166
2167 c = condition_new(CONDITION_NULL, NULL, trigger, negate);
2168 if (!c)
2169 return log_oom();
2170
2171 LIST_PREPEND(conditions, *list, c);
2172 return 0;
2173 }
2174
2175 DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier");
2176 DEFINE_CONFIG_PARSE_ENUM(config_parse_failure_action, failure_action, FailureAction, "Failed to parse failure action specifier");
2177
2178 int config_parse_unit_requires_mounts_for(
2179 const char *unit,
2180 const char *filename,
2181 unsigned line,
2182 const char *section,
2183 unsigned section_line,
2184 const char *lvalue,
2185 int ltype,
2186 const char *rvalue,
2187 void *data,
2188 void *userdata) {
2189
2190 Unit *u = userdata;
2191 const char *word, *state;
2192 size_t l;
2193
2194 assert(filename);
2195 assert(lvalue);
2196 assert(rvalue);
2197 assert(data);
2198
2199 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
2200 int r;
2201 _cleanup_free_ char *n;
2202
2203 n = strndup(word, l);
2204 if (!n)
2205 return log_oom();
2206
2207 if (!utf8_is_valid(n)) {
2208 log_invalid_utf8(unit, LOG_ERR, filename, line, EINVAL, rvalue);
2209 continue;
2210 }
2211
2212 r = unit_require_mounts_for(u, n);
2213 if (r < 0) {
2214 log_syntax(unit, LOG_ERR, filename, line, -r,
2215 "Failed to add required mount for, ignoring: %s", rvalue);
2216 continue;
2217 }
2218 }
2219 if (!isempty(state))
2220 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2221 "Trailing garbage, ignoring.");
2222
2223 return 0;
2224 }
2225
2226 int config_parse_documentation(const char *unit,
2227 const char *filename,
2228 unsigned line,
2229 const char *section,
2230 unsigned section_line,
2231 const char *lvalue,
2232 int ltype,
2233 const char *rvalue,
2234 void *data,
2235 void *userdata) {
2236
2237 Unit *u = userdata;
2238 int r;
2239 char **a, **b;
2240
2241 assert(filename);
2242 assert(lvalue);
2243 assert(rvalue);
2244 assert(u);
2245
2246 if (isempty(rvalue)) {
2247 /* Empty assignment resets the list */
2248 strv_free(u->documentation);
2249 u->documentation = NULL;
2250 return 0;
2251 }
2252
2253 r = config_parse_unit_strv_printf(unit, filename, line, section, section_line, lvalue, ltype,
2254 rvalue, data, userdata);
2255 if (r < 0)
2256 return r;
2257
2258 for (a = b = u->documentation; a && *a; a++) {
2259
2260 if (documentation_url_is_valid(*a))
2261 *(b++) = *a;
2262 else {
2263 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2264 "Invalid URL, ignoring: %s", *a);
2265 free(*a);
2266 }
2267 }
2268 if (b)
2269 *b = NULL;
2270
2271 return r;
2272 }
2273
2274 #ifdef HAVE_SECCOMP
2275 int config_parse_syscall_filter(
2276 const char *unit,
2277 const char *filename,
2278 unsigned line,
2279 const char *section,
2280 unsigned section_line,
2281 const char *lvalue,
2282 int ltype,
2283 const char *rvalue,
2284 void *data,
2285 void *userdata) {
2286
2287 static const char default_syscalls[] =
2288 "execve\0"
2289 "exit\0"
2290 "exit_group\0"
2291 "rt_sigreturn\0"
2292 "sigreturn\0";
2293
2294 ExecContext *c = data;
2295 Unit *u = userdata;
2296 bool invert = false;
2297 const char *word, *state;
2298 size_t l;
2299 int r;
2300
2301 assert(filename);
2302 assert(lvalue);
2303 assert(rvalue);
2304 assert(u);
2305
2306 if (isempty(rvalue)) {
2307 /* Empty assignment resets the list */
2308 set_free(c->syscall_filter);
2309 c->syscall_filter = NULL;
2310 c->syscall_whitelist = false;
2311 return 0;
2312 }
2313
2314 if (rvalue[0] == '~') {
2315 invert = true;
2316 rvalue++;
2317 }
2318
2319 if (!c->syscall_filter) {
2320 c->syscall_filter = set_new(NULL);
2321 if (!c->syscall_filter)
2322 return log_oom();
2323
2324 if (invert)
2325 /* Allow everything but the ones listed */
2326 c->syscall_whitelist = false;
2327 else {
2328 const char *i;
2329
2330 /* Allow nothing but the ones listed */
2331 c->syscall_whitelist = true;
2332
2333 /* Accept default syscalls if we are on a whitelist */
2334 NULSTR_FOREACH(i, default_syscalls) {
2335 int id;
2336
2337 id = seccomp_syscall_resolve_name(i);
2338 if (id < 0)
2339 continue;
2340
2341 r = set_put(c->syscall_filter, INT_TO_PTR(id + 1));
2342 if (r == 0)
2343 continue;
2344 if (r < 0)
2345 return log_oom();
2346 }
2347 }
2348 }
2349
2350 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
2351 _cleanup_free_ char *t = NULL;
2352 int id;
2353
2354 t = strndup(word, l);
2355 if (!t)
2356 return log_oom();
2357
2358 id = seccomp_syscall_resolve_name(t);
2359 if (id < 0) {
2360 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2361 "Failed to parse system call, ignoring: %s", t);
2362 continue;
2363 }
2364
2365 /* If we previously wanted to forbid a syscall and now
2366 * we want to allow it, then remove it from the list
2367 */
2368 if (!invert == c->syscall_whitelist) {
2369 r = set_put(c->syscall_filter, INT_TO_PTR(id + 1));
2370 if (r == 0)
2371 continue;
2372 if (r < 0)
2373 return log_oom();
2374 } else
2375 set_remove(c->syscall_filter, INT_TO_PTR(id + 1));
2376 }
2377 if (!isempty(state))
2378 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2379 "Trailing garbage, ignoring.");
2380
2381 /* Turn on NNP, but only if it wasn't configured explicitly
2382 * before, and only if we are in user mode. */
2383 if (!c->no_new_privileges_set && u->manager->running_as == MANAGER_USER)
2384 c->no_new_privileges = true;
2385
2386 return 0;
2387 }
2388
2389 int config_parse_syscall_archs(
2390 const char *unit,
2391 const char *filename,
2392 unsigned line,
2393 const char *section,
2394 unsigned section_line,
2395 const char *lvalue,
2396 int ltype,
2397 const char *rvalue,
2398 void *data,
2399 void *userdata) {
2400
2401 Set **archs = data;
2402 const char *word, *state;
2403 size_t l;
2404 int r;
2405
2406 if (isempty(rvalue)) {
2407 set_free(*archs);
2408 *archs = NULL;
2409 return 0;
2410 }
2411
2412 r = set_ensure_allocated(archs, NULL);
2413 if (r < 0)
2414 return log_oom();
2415
2416 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
2417 _cleanup_free_ char *t = NULL;
2418 uint32_t a;
2419
2420 t = strndup(word, l);
2421 if (!t)
2422 return log_oom();
2423
2424 r = seccomp_arch_from_string(t, &a);
2425 if (r < 0) {
2426 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2427 "Failed to parse system call architecture, ignoring: %s", t);
2428 continue;
2429 }
2430
2431 r = set_put(*archs, UINT32_TO_PTR(a + 1));
2432 if (r == 0)
2433 continue;
2434 if (r < 0)
2435 return log_oom();
2436 }
2437 if (!isempty(state))
2438 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2439 "Trailing garbage, ignoring.");
2440
2441 return 0;
2442 }
2443
2444 int config_parse_syscall_errno(
2445 const char *unit,
2446 const char *filename,
2447 unsigned line,
2448 const char *section,
2449 unsigned section_line,
2450 const char *lvalue,
2451 int ltype,
2452 const char *rvalue,
2453 void *data,
2454 void *userdata) {
2455
2456 ExecContext *c = data;
2457 int e;
2458
2459 assert(filename);
2460 assert(lvalue);
2461 assert(rvalue);
2462
2463 if (isempty(rvalue)) {
2464 /* Empty assignment resets to KILL */
2465 c->syscall_errno = 0;
2466 return 0;
2467 }
2468
2469 e = errno_from_name(rvalue);
2470 if (e < 0) {
2471 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2472 "Failed to parse error number, ignoring: %s", rvalue);
2473 return 0;
2474 }
2475
2476 c->syscall_errno = e;
2477 return 0;
2478 }
2479
2480 int config_parse_address_families(
2481 const char *unit,
2482 const char *filename,
2483 unsigned line,
2484 const char *section,
2485 unsigned section_line,
2486 const char *lvalue,
2487 int ltype,
2488 const char *rvalue,
2489 void *data,
2490 void *userdata) {
2491
2492 ExecContext *c = data;
2493 bool invert = false;
2494 const char *word, *state;
2495 size_t l;
2496 int r;
2497
2498 assert(filename);
2499 assert(lvalue);
2500 assert(rvalue);
2501
2502 if (isempty(rvalue)) {
2503 /* Empty assignment resets the list */
2504 set_free(c->address_families);
2505 c->address_families = NULL;
2506 c->address_families_whitelist = false;
2507 return 0;
2508 }
2509
2510 if (rvalue[0] == '~') {
2511 invert = true;
2512 rvalue++;
2513 }
2514
2515 if (!c->address_families) {
2516 c->address_families = set_new(NULL);
2517 if (!c->address_families)
2518 return log_oom();
2519
2520 c->address_families_whitelist = !invert;
2521 }
2522
2523 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
2524 _cleanup_free_ char *t = NULL;
2525 int af;
2526
2527 t = strndup(word, l);
2528 if (!t)
2529 return log_oom();
2530
2531 af = af_from_name(t);
2532 if (af <= 0) {
2533 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2534 "Failed to parse address family, ignoring: %s", t);
2535 continue;
2536 }
2537
2538 /* If we previously wanted to forbid an address family and now
2539 * we want to allow it, then remove it from the list
2540 */
2541 if (!invert == c->address_families_whitelist) {
2542 r = set_put(c->address_families, INT_TO_PTR(af));
2543 if (r == 0)
2544 continue;
2545 if (r < 0)
2546 return log_oom();
2547 } else
2548 set_remove(c->address_families, INT_TO_PTR(af));
2549 }
2550 if (!isempty(state))
2551 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2552 "Trailing garbage, ignoring.");
2553
2554 return 0;
2555 }
2556 #endif
2557
2558 int config_parse_unit_slice(
2559 const char *unit,
2560 const char *filename,
2561 unsigned line,
2562 const char *section,
2563 unsigned section_line,
2564 const char *lvalue,
2565 int ltype,
2566 const char *rvalue,
2567 void *data,
2568 void *userdata) {
2569
2570 _cleanup_free_ char *k = NULL;
2571 Unit *u = userdata, *slice = NULL;
2572 int r;
2573
2574 assert(filename);
2575 assert(lvalue);
2576 assert(rvalue);
2577 assert(u);
2578
2579 r = unit_name_printf(u, rvalue, &k);
2580 if (r < 0) {
2581 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to resolve unit specifiers on %s. Ignoring.", rvalue);
2582 return 0;
2583 }
2584
2585 r = manager_load_unit(u->manager, k, NULL, NULL, &slice);
2586 if (r < 0) {
2587 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to load slice unit %s. Ignoring.", k);
2588 return 0;
2589 }
2590
2591 r = unit_set_slice(u, slice);
2592 if (r < 0) {
2593 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to assign slice %s to unit %s. Ignoring.", slice->id, u->id);
2594 return 0;
2595 }
2596
2597 return 0;
2598 }
2599
2600 DEFINE_CONFIG_PARSE_ENUM(config_parse_device_policy, cgroup_device_policy, CGroupDevicePolicy, "Failed to parse device policy");
2601
2602 int config_parse_cpu_shares(
2603 const char *unit,
2604 const char *filename,
2605 unsigned line,
2606 const char *section,
2607 unsigned section_line,
2608 const char *lvalue,
2609 int ltype,
2610 const char *rvalue,
2611 void *data,
2612 void *userdata) {
2613
2614 unsigned long *shares = data, lu;
2615 int r;
2616
2617 assert(filename);
2618 assert(lvalue);
2619 assert(rvalue);
2620
2621 if (isempty(rvalue)) {
2622 *shares = (unsigned long) -1;
2623 return 0;
2624 }
2625
2626 r = safe_atolu(rvalue, &lu);
2627 if (r < 0 || lu <= 0) {
2628 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2629 "CPU shares '%s' invalid. Ignoring.", rvalue);
2630 return 0;
2631 }
2632
2633 *shares = lu;
2634 return 0;
2635 }
2636
2637 int config_parse_cpu_quota(
2638 const char *unit,
2639 const char *filename,
2640 unsigned line,
2641 const char *section,
2642 unsigned section_line,
2643 const char *lvalue,
2644 int ltype,
2645 const char *rvalue,
2646 void *data,
2647 void *userdata) {
2648
2649 CGroupContext *c = data;
2650 double percent;
2651
2652 assert(filename);
2653 assert(lvalue);
2654 assert(rvalue);
2655
2656 if (isempty(rvalue)) {
2657 c->cpu_quota_per_sec_usec = USEC_INFINITY;
2658 return 0;
2659 }
2660
2661 if (!endswith(rvalue, "%")) {
2662
2663 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2664 "CPU quota '%s' not ending in '%%'. Ignoring.", rvalue);
2665 return 0;
2666 }
2667
2668 if (sscanf(rvalue, "%lf%%", &percent) != 1 || percent <= 0) {
2669 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2670 "CPU quota '%s' invalid. Ignoring.", rvalue);
2671 return 0;
2672 }
2673
2674 c->cpu_quota_per_sec_usec = (usec_t) (percent * USEC_PER_SEC / 100);
2675
2676 return 0;
2677 }
2678
2679 int config_parse_memory_limit(
2680 const char *unit,
2681 const char *filename,
2682 unsigned line,
2683 const char *section,
2684 unsigned section_line,
2685 const char *lvalue,
2686 int ltype,
2687 const char *rvalue,
2688 void *data,
2689 void *userdata) {
2690
2691 CGroupContext *c = data;
2692 off_t bytes;
2693 int r;
2694
2695 if (isempty(rvalue)) {
2696 c->memory_limit = (uint64_t) -1;
2697 return 0;
2698 }
2699
2700 assert_cc(sizeof(uint64_t) == sizeof(off_t));
2701
2702 r = parse_size(rvalue, 1024, &bytes);
2703 if (r < 0) {
2704 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2705 "Memory limit '%s' invalid. Ignoring.", rvalue);
2706 return 0;
2707 }
2708
2709 c->memory_limit = (uint64_t) bytes;
2710 return 0;
2711 }
2712
2713 int config_parse_device_allow(
2714 const char *unit,
2715 const char *filename,
2716 unsigned line,
2717 const char *section,
2718 unsigned section_line,
2719 const char *lvalue,
2720 int ltype,
2721 const char *rvalue,
2722 void *data,
2723 void *userdata) {
2724
2725 _cleanup_free_ char *path = NULL;
2726 CGroupContext *c = data;
2727 CGroupDeviceAllow *a;
2728 const char *m;
2729 size_t n;
2730
2731 if (isempty(rvalue)) {
2732 while (c->device_allow)
2733 cgroup_context_free_device_allow(c, c->device_allow);
2734
2735 return 0;
2736 }
2737
2738 n = strcspn(rvalue, WHITESPACE);
2739 path = strndup(rvalue, n);
2740 if (!path)
2741 return log_oom();
2742
2743 if (!startswith(path, "/dev/") &&
2744 !startswith(path, "block-") &&
2745 !startswith(path, "char-")) {
2746 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2747 "Invalid device node path '%s'. Ignoring.", path);
2748 return 0;
2749 }
2750
2751 m = rvalue + n + strspn(rvalue + n, WHITESPACE);
2752 if (isempty(m))
2753 m = "rwm";
2754
2755 if (!in_charset(m, "rwm")) {
2756 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2757 "Invalid device rights '%s'. Ignoring.", m);
2758 return 0;
2759 }
2760
2761 a = new0(CGroupDeviceAllow, 1);
2762 if (!a)
2763 return log_oom();
2764
2765 a->path = path;
2766 path = NULL;
2767 a->r = !!strchr(m, 'r');
2768 a->w = !!strchr(m, 'w');
2769 a->m = !!strchr(m, 'm');
2770
2771 LIST_PREPEND(device_allow, c->device_allow, a);
2772 return 0;
2773 }
2774
2775 int config_parse_blockio_weight(
2776 const char *unit,
2777 const char *filename,
2778 unsigned line,
2779 const char *section,
2780 unsigned section_line,
2781 const char *lvalue,
2782 int ltype,
2783 const char *rvalue,
2784 void *data,
2785 void *userdata) {
2786
2787 unsigned long *weight = data, lu;
2788 int r;
2789
2790 assert(filename);
2791 assert(lvalue);
2792 assert(rvalue);
2793
2794 if (isempty(rvalue)) {
2795 *weight = (unsigned long) -1;
2796 return 0;
2797 }
2798
2799 r = safe_atolu(rvalue, &lu);
2800 if (r < 0 || lu < 10 || lu > 1000) {
2801 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2802 "Block IO weight '%s' invalid. Ignoring.", rvalue);
2803 return 0;
2804 }
2805
2806 *weight = lu;
2807 return 0;
2808 }
2809
2810 int config_parse_blockio_device_weight(
2811 const char *unit,
2812 const char *filename,
2813 unsigned line,
2814 const char *section,
2815 unsigned section_line,
2816 const char *lvalue,
2817 int ltype,
2818 const char *rvalue,
2819 void *data,
2820 void *userdata) {
2821
2822 _cleanup_free_ char *path = NULL;
2823 CGroupBlockIODeviceWeight *w;
2824 CGroupContext *c = data;
2825 unsigned long lu;
2826 const char *weight;
2827 size_t n;
2828 int r;
2829
2830 assert(filename);
2831 assert(lvalue);
2832 assert(rvalue);
2833
2834 if (isempty(rvalue)) {
2835 while (c->blockio_device_weights)
2836 cgroup_context_free_blockio_device_weight(c, c->blockio_device_weights);
2837
2838 return 0;
2839 }
2840
2841 n = strcspn(rvalue, WHITESPACE);
2842 weight = rvalue + n;
2843 if (!*weight) {
2844 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2845 "Expected block device and device weight. Ignoring.");
2846 return 0;
2847 }
2848
2849 path = strndup(rvalue, n);
2850 if (!path)
2851 return log_oom();
2852
2853 if (!path_startswith(path, "/dev")) {
2854 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2855 "Invalid device node path '%s'. Ignoring.", path);
2856 return 0;
2857 }
2858
2859 weight += strspn(weight, WHITESPACE);
2860 r = safe_atolu(weight, &lu);
2861 if (r < 0 || lu < 10 || lu > 1000) {
2862 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2863 "Block IO weight '%s' invalid. Ignoring.", rvalue);
2864 return 0;
2865 }
2866
2867 w = new0(CGroupBlockIODeviceWeight, 1);
2868 if (!w)
2869 return log_oom();
2870
2871 w->path = path;
2872 path = NULL;
2873
2874 w->weight = lu;
2875
2876 LIST_PREPEND(device_weights, c->blockio_device_weights, w);
2877 return 0;
2878 }
2879
2880 int config_parse_blockio_bandwidth(
2881 const char *unit,
2882 const char *filename,
2883 unsigned line,
2884 const char *section,
2885 unsigned section_line,
2886 const char *lvalue,
2887 int ltype,
2888 const char *rvalue,
2889 void *data,
2890 void *userdata) {
2891
2892 _cleanup_free_ char *path = NULL;
2893 CGroupBlockIODeviceBandwidth *b;
2894 CGroupContext *c = data;
2895 const char *bandwidth;
2896 off_t bytes;
2897 bool read;
2898 size_t n;
2899 int r;
2900
2901 assert(filename);
2902 assert(lvalue);
2903 assert(rvalue);
2904
2905 read = streq("BlockIOReadBandwidth", lvalue);
2906
2907 if (isempty(rvalue)) {
2908 CGroupBlockIODeviceBandwidth *next;
2909
2910 LIST_FOREACH_SAFE (device_bandwidths, b, next, c->blockio_device_bandwidths)
2911 if (b->read == read)
2912 cgroup_context_free_blockio_device_bandwidth(c, b);
2913
2914 return 0;
2915 }
2916
2917 n = strcspn(rvalue, WHITESPACE);
2918 bandwidth = rvalue + n;
2919 bandwidth += strspn(bandwidth, WHITESPACE);
2920
2921 if (!*bandwidth) {
2922 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2923 "Expected space separated pair of device node and bandwidth. Ignoring.");
2924 return 0;
2925 }
2926
2927 path = strndup(rvalue, n);
2928 if (!path)
2929 return log_oom();
2930
2931 if (!path_startswith(path, "/dev")) {
2932 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2933 "Invalid device node path '%s'. Ignoring.", path);
2934 return 0;
2935 }
2936
2937 r = parse_size(bandwidth, 1000, &bytes);
2938 if (r < 0 || bytes <= 0) {
2939 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2940 "Block IO Bandwidth '%s' invalid. Ignoring.", rvalue);
2941 return 0;
2942 }
2943
2944 b = new0(CGroupBlockIODeviceBandwidth, 1);
2945 if (!b)
2946 return log_oom();
2947
2948 b->path = path;
2949 path = NULL;
2950 b->bandwidth = (uint64_t) bytes;
2951 b->read = read;
2952
2953 LIST_PREPEND(device_bandwidths, c->blockio_device_bandwidths, b);
2954
2955 return 0;
2956 }
2957
2958 DEFINE_CONFIG_PARSE_ENUM(config_parse_job_mode, job_mode, JobMode, "Failed to parse job mode");
2959
2960 int config_parse_job_mode_isolate(
2961 const char *unit,
2962 const char *filename,
2963 unsigned line,
2964 const char *section,
2965 unsigned section_line,
2966 const char *lvalue,
2967 int ltype,
2968 const char *rvalue,
2969 void *data,
2970 void *userdata) {
2971
2972 JobMode *m = data;
2973 int r;
2974
2975 assert(filename);
2976 assert(lvalue);
2977 assert(rvalue);
2978
2979 r = parse_boolean(rvalue);
2980 if (r < 0) {
2981 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
2982 "Failed to parse boolean, ignoring: %s", rvalue);
2983 return 0;
2984 }
2985
2986 *m = r ? JOB_ISOLATE : JOB_REPLACE;
2987 return 0;
2988 }
2989
2990 int config_parse_runtime_directory(
2991 const char *unit,
2992 const char *filename,
2993 unsigned line,
2994 const char *section,
2995 unsigned section_line,
2996 const char *lvalue,
2997 int ltype,
2998 const char *rvalue,
2999 void *data,
3000 void *userdata) {
3001
3002 char***rt = data;
3003 const char *word, *state;
3004 size_t l;
3005 int r;
3006
3007 assert(filename);
3008 assert(lvalue);
3009 assert(rvalue);
3010 assert(data);
3011
3012 if (isempty(rvalue)) {
3013 /* Empty assignment resets the list */
3014 strv_free(*rt);
3015 *rt = NULL;
3016 return 0;
3017 }
3018
3019 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
3020 _cleanup_free_ char *n;
3021
3022 n = strndup(word, l);
3023 if (!n)
3024 return log_oom();
3025
3026 if (!filename_is_valid(n)) {
3027 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
3028 "Runtime directory is not valid, ignoring assignment: %s", rvalue);
3029 continue;
3030 }
3031
3032 r = strv_push(rt, n);
3033 if (r < 0)
3034 return log_oom();
3035
3036 n = NULL;
3037 }
3038 if (!isempty(state))
3039 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
3040 "Trailing garbage, ignoring.");
3041
3042 return 0;
3043 }
3044
3045 int config_parse_set_status(
3046 const char *unit,
3047 const char *filename,
3048 unsigned line,
3049 const char *section,
3050 unsigned section_line,
3051 const char *lvalue,
3052 int ltype,
3053 const char *rvalue,
3054 void *data,
3055 void *userdata) {
3056
3057 size_t l;
3058 const char *word, *state;
3059 int r;
3060 ExitStatusSet *status_set = data;
3061
3062 assert(filename);
3063 assert(lvalue);
3064 assert(rvalue);
3065 assert(data);
3066
3067 /* Empty assignment resets the list */
3068 if (isempty(rvalue)) {
3069 exit_status_set_free(status_set);
3070 return 0;
3071 }
3072
3073 FOREACH_WORD(word, l, rvalue, state) {
3074 _cleanup_free_ char *temp;
3075 int val;
3076 Set **set;
3077
3078 temp = strndup(word, l);
3079 if (!temp)
3080 return log_oom();
3081
3082 r = safe_atoi(temp, &val);
3083 if (r < 0) {
3084 val = signal_from_string_try_harder(temp);
3085
3086 if (val <= 0) {
3087 log_syntax(unit, LOG_ERR, filename, line, -val,
3088 "Failed to parse value, ignoring: %s", word);
3089 continue;
3090 }
3091 set = &status_set->signal;
3092 } else {
3093 if (val < 0 || val > 255) {
3094 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
3095 "Value %d is outside range 0-255, ignoring", val);
3096 continue;
3097 }
3098 set = &status_set->status;
3099 }
3100
3101 r = set_ensure_allocated(set, NULL);
3102 if (r < 0)
3103 return log_oom();
3104
3105 r = set_put(*set, INT_TO_PTR(val));
3106 if (r < 0) {
3107 log_syntax(unit, LOG_ERR, filename, line, -r,
3108 "Unable to store: %s", word);
3109 return r;
3110 }
3111 }
3112 if (!isempty(state))
3113 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
3114 "Trailing garbage, ignoring.");
3115
3116 return 0;
3117 }
3118
3119 int config_parse_namespace_path_strv(
3120 const char *unit,
3121 const char *filename,
3122 unsigned line,
3123 const char *section,
3124 unsigned section_line,
3125 const char *lvalue,
3126 int ltype,
3127 const char *rvalue,
3128 void *data,
3129 void *userdata) {
3130
3131 char*** sv = data;
3132 const char *word, *state;
3133 size_t l;
3134 int r;
3135
3136 assert(filename);
3137 assert(lvalue);
3138 assert(rvalue);
3139 assert(data);
3140
3141 if (isempty(rvalue)) {
3142 /* Empty assignment resets the list */
3143 strv_free(*sv);
3144 *sv = NULL;
3145 return 0;
3146 }
3147
3148 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
3149 _cleanup_free_ char *n;
3150 int offset;
3151
3152 n = strndup(word, l);
3153 if (!n)
3154 return log_oom();
3155
3156 if (!utf8_is_valid(n)) {
3157 log_invalid_utf8(unit, LOG_ERR, filename, line, EINVAL, rvalue);
3158 continue;
3159 }
3160
3161 offset = n[0] == '-';
3162 if (!path_is_absolute(n + offset)) {
3163 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
3164 "Not an absolute path, ignoring: %s", rvalue);
3165 continue;
3166 }
3167
3168 path_kill_slashes(n);
3169
3170 r = strv_push(sv, n);
3171 if (r < 0)
3172 return log_oom();
3173
3174 n = NULL;
3175 }
3176 if (!isempty(state))
3177 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
3178 "Trailing garbage, ignoring.");
3179
3180 return 0;
3181 }
3182
3183 int config_parse_no_new_privileges(
3184 const char* unit,
3185 const char *filename,
3186 unsigned line,
3187 const char *section,
3188 unsigned section_line,
3189 const char *lvalue,
3190 int ltype,
3191 const char *rvalue,
3192 void *data,
3193 void *userdata) {
3194
3195 ExecContext *c = data;
3196 int k;
3197
3198 assert(filename);
3199 assert(lvalue);
3200 assert(rvalue);
3201 assert(data);
3202
3203 k = parse_boolean(rvalue);
3204 if (k < 0) {
3205 log_syntax(unit, LOG_ERR, filename, line, -k,
3206 "Failed to parse boolean value, ignoring: %s", rvalue);
3207 return 0;
3208 }
3209
3210 c->no_new_privileges = !!k;
3211 c->no_new_privileges_set = true;
3212
3213 return 0;
3214 }
3215
3216 int config_parse_protect_home(
3217 const char* unit,
3218 const char *filename,
3219 unsigned line,
3220 const char *section,
3221 unsigned section_line,
3222 const char *lvalue,
3223 int ltype,
3224 const char *rvalue,
3225 void *data,
3226 void *userdata) {
3227
3228 ExecContext *c = data;
3229 int k;
3230
3231 assert(filename);
3232 assert(lvalue);
3233 assert(rvalue);
3234 assert(data);
3235
3236 /* Our enum shall be a superset of booleans, hence first try
3237 * to parse as as boolean, and then as enum */
3238
3239 k = parse_boolean(rvalue);
3240 if (k > 0)
3241 c->protect_home = PROTECT_HOME_YES;
3242 else if (k == 0)
3243 c->protect_home = PROTECT_HOME_NO;
3244 else {
3245 ProtectHome h;
3246
3247 h = protect_home_from_string(rvalue);
3248 if (h < 0){
3249 log_syntax(unit, LOG_ERR, filename, line, -h,
3250 "Failed to parse protect home value, ignoring: %s", rvalue);
3251 return 0;
3252 }
3253
3254 c->protect_home = h;
3255 }
3256
3257 return 0;
3258 }
3259
3260 int config_parse_protect_system(
3261 const char* unit,
3262 const char *filename,
3263 unsigned line,
3264 const char *section,
3265 unsigned section_line,
3266 const char *lvalue,
3267 int ltype,
3268 const char *rvalue,
3269 void *data,
3270 void *userdata) {
3271
3272 ExecContext *c = data;
3273 int k;
3274
3275 assert(filename);
3276 assert(lvalue);
3277 assert(rvalue);
3278 assert(data);
3279
3280 /* Our enum shall be a superset of booleans, hence first try
3281 * to parse as as boolean, and then as enum */
3282
3283 k = parse_boolean(rvalue);
3284 if (k > 0)
3285 c->protect_system = PROTECT_SYSTEM_YES;
3286 else if (k == 0)
3287 c->protect_system = PROTECT_SYSTEM_NO;
3288 else {
3289 ProtectSystem s;
3290
3291 s = protect_system_from_string(rvalue);
3292 if (s < 0){
3293 log_syntax(unit, LOG_ERR, filename, line, -s,
3294 "Failed to parse protect system value, ignoring: %s", rvalue);
3295 return 0;
3296 }
3297
3298 c->protect_system = s;
3299 }
3300
3301 return 0;
3302 }
3303
3304 #define FOLLOW_MAX 8
3305
3306 static int open_follow(char **filename, FILE **_f, Set *names, char **_final) {
3307 unsigned c = 0;
3308 int fd, r;
3309 FILE *f;
3310 char *id = NULL;
3311
3312 assert(filename);
3313 assert(*filename);
3314 assert(_f);
3315 assert(names);
3316
3317 /* This will update the filename pointer if the loaded file is
3318 * reached by a symlink. The old string will be freed. */
3319
3320 for (;;) {
3321 char *target, *name;
3322
3323 if (c++ >= FOLLOW_MAX)
3324 return -ELOOP;
3325
3326 path_kill_slashes(*filename);
3327
3328 /* Add the file name we are currently looking at to
3329 * the names of this unit, but only if it is a valid
3330 * unit name. */
3331 name = basename(*filename);
3332
3333 if (unit_name_is_valid(name, UNIT_NAME_ANY)) {
3334
3335 id = set_get(names, name);
3336 if (!id) {
3337 id = strdup(name);
3338 if (!id)
3339 return -ENOMEM;
3340
3341 r = set_consume(names, id);
3342 if (r < 0)
3343 return r;
3344 }
3345 }
3346
3347 /* Try to open the file name, but don't if its a symlink */
3348 fd = open(*filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
3349 if (fd >= 0)
3350 break;
3351
3352 if (errno != ELOOP)
3353 return -errno;
3354
3355 /* Hmm, so this is a symlink. Let's read the name, and follow it manually */
3356 r = readlink_and_make_absolute(*filename, &target);
3357 if (r < 0)
3358 return r;
3359
3360 free(*filename);
3361 *filename = target;
3362 }
3363
3364 f = fdopen(fd, "re");
3365 if (!f) {
3366 safe_close(fd);
3367 return -errno;
3368 }
3369
3370 *_f = f;
3371 *_final = id;
3372 return 0;
3373 }
3374
3375 static int merge_by_names(Unit **u, Set *names, const char *id) {
3376 char *k;
3377 int r;
3378
3379 assert(u);
3380 assert(*u);
3381 assert(names);
3382
3383 /* Let's try to add in all symlink names we found */
3384 while ((k = set_steal_first(names))) {
3385
3386 /* First try to merge in the other name into our
3387 * unit */
3388 r = unit_merge_by_name(*u, k);
3389 if (r < 0) {
3390 Unit *other;
3391
3392 /* Hmm, we couldn't merge the other unit into
3393 * ours? Then let's try it the other way
3394 * round */
3395
3396 other = manager_get_unit((*u)->manager, k);
3397 free(k);
3398
3399 if (other) {
3400 r = unit_merge(other, *u);
3401 if (r >= 0) {
3402 *u = other;
3403 return merge_by_names(u, names, NULL);
3404 }
3405 }
3406
3407 return r;
3408 }
3409
3410 if (id == k)
3411 unit_choose_id(*u, id);
3412
3413 free(k);
3414 }
3415
3416 return 0;
3417 }
3418
3419 static int load_from_path(Unit *u, const char *path) {
3420 int r;
3421 _cleanup_set_free_free_ Set *symlink_names = NULL;
3422 _cleanup_fclose_ FILE *f = NULL;
3423 _cleanup_free_ char *filename = NULL;
3424 char *id = NULL;
3425 Unit *merged;
3426 struct stat st;
3427
3428 assert(u);
3429 assert(path);
3430
3431 symlink_names = set_new(&string_hash_ops);
3432 if (!symlink_names)
3433 return -ENOMEM;
3434
3435 if (path_is_absolute(path)) {
3436
3437 filename = strdup(path);
3438 if (!filename)
3439 return -ENOMEM;
3440
3441 r = open_follow(&filename, &f, symlink_names, &id);
3442 if (r < 0) {
3443 filename = mfree(filename);
3444 if (r != -ENOENT)
3445 return r;
3446 }
3447
3448 } else {
3449 char **p;
3450
3451 STRV_FOREACH(p, u->manager->lookup_paths.unit_path) {
3452
3453 /* Instead of opening the path right away, we manually
3454 * follow all symlinks and add their name to our unit
3455 * name set while doing so */
3456 filename = path_make_absolute(path, *p);
3457 if (!filename)
3458 return -ENOMEM;
3459
3460 if (u->manager->unit_path_cache &&
3461 !set_get(u->manager->unit_path_cache, filename))
3462 r = -ENOENT;
3463 else
3464 r = open_follow(&filename, &f, symlink_names, &id);
3465
3466 if (r < 0) {
3467 filename = mfree(filename);
3468 if (r != -ENOENT)
3469 return r;
3470
3471 /* Empty the symlink names for the next run */
3472 set_clear_free(symlink_names);
3473 continue;
3474 }
3475
3476 break;
3477 }
3478 }
3479
3480 if (!filename)
3481 /* Hmm, no suitable file found? */
3482 return 0;
3483
3484 merged = u;
3485 r = merge_by_names(&merged, symlink_names, id);
3486 if (r < 0)
3487 return r;
3488
3489 if (merged != u) {
3490 u->load_state = UNIT_MERGED;
3491 return 0;
3492 }
3493
3494 if (fstat(fileno(f), &st) < 0)
3495 return -errno;
3496
3497 if (null_or_empty(&st))
3498 u->load_state = UNIT_MASKED;
3499 else {
3500 u->load_state = UNIT_LOADED;
3501
3502 /* Now, parse the file contents */
3503 r = config_parse(u->id, filename, f,
3504 UNIT_VTABLE(u)->sections,
3505 config_item_perf_lookup, load_fragment_gperf_lookup,
3506 false, true, false, u);
3507 if (r < 0)
3508 return r;
3509 }
3510
3511 free(u->fragment_path);
3512 u->fragment_path = filename;
3513 filename = NULL;
3514
3515 u->fragment_mtime = timespec_load(&st.st_mtim);
3516
3517 if (u->source_path) {
3518 if (stat(u->source_path, &st) >= 0)
3519 u->source_mtime = timespec_load(&st.st_mtim);
3520 else
3521 u->source_mtime = 0;
3522 }
3523
3524 return 0;
3525 }
3526
3527 int unit_load_fragment(Unit *u) {
3528 int r;
3529 Iterator i;
3530 const char *t;
3531
3532 assert(u);
3533 assert(u->load_state == UNIT_STUB);
3534 assert(u->id);
3535
3536 if (u->transient) {
3537 u->load_state = UNIT_LOADED;
3538 return 0;
3539 }
3540
3541 /* First, try to find the unit under its id. We always look
3542 * for unit files in the default directories, to make it easy
3543 * to override things by placing things in /etc/systemd/system */
3544 r = load_from_path(u, u->id);
3545 if (r < 0)
3546 return r;
3547
3548 /* Try to find an alias we can load this with */
3549 if (u->load_state == UNIT_STUB) {
3550 SET_FOREACH(t, u->names, i) {
3551
3552 if (t == u->id)
3553 continue;
3554
3555 r = load_from_path(u, t);
3556 if (r < 0)
3557 return r;
3558
3559 if (u->load_state != UNIT_STUB)
3560 break;
3561 }
3562 }
3563
3564 /* And now, try looking for it under the suggested (originally linked) path */
3565 if (u->load_state == UNIT_STUB && u->fragment_path) {
3566
3567 r = load_from_path(u, u->fragment_path);
3568 if (r < 0)
3569 return r;
3570
3571 if (u->load_state == UNIT_STUB)
3572 /* Hmm, this didn't work? Then let's get rid
3573 * of the fragment path stored for us, so that
3574 * we don't point to an invalid location. */
3575 u->fragment_path = mfree(u->fragment_path);
3576 }
3577
3578 /* Look for a template */
3579 if (u->load_state == UNIT_STUB && u->instance) {
3580 _cleanup_free_ char *k = NULL;
3581
3582 r = unit_name_template(u->id, &k);
3583 if (r < 0)
3584 return r;
3585
3586 r = load_from_path(u, k);
3587 if (r < 0)
3588 return r;
3589
3590 if (u->load_state == UNIT_STUB) {
3591 SET_FOREACH(t, u->names, i) {
3592 _cleanup_free_ char *z = NULL;
3593
3594 if (t == u->id)
3595 continue;
3596
3597 r = unit_name_template(t, &z);
3598 if (r < 0)
3599 return r;
3600
3601 r = load_from_path(u, z);
3602 if (r < 0)
3603 return r;
3604
3605 if (u->load_state != UNIT_STUB)
3606 break;
3607 }
3608 }
3609 }
3610
3611 return 0;
3612 }
3613
3614 void unit_dump_config_items(FILE *f) {
3615 static const struct {
3616 const ConfigParserCallback callback;
3617 const char *rvalue;
3618 } table[] = {
3619 #if !defined(HAVE_SYSV_COMPAT) || !defined(HAVE_SECCOMP) || !defined(HAVE_PAM) || !defined(HAVE_SELINUX) || !defined(HAVE_SMACK) || !defined(HAVE_APPARMOR)
3620 { config_parse_warn_compat, "NOTSUPPORTED" },
3621 #endif
3622 { config_parse_int, "INTEGER" },
3623 { config_parse_unsigned, "UNSIGNED" },
3624 { config_parse_iec_size, "SIZE" },
3625 { config_parse_iec_off, "SIZE" },
3626 { config_parse_si_size, "SIZE" },
3627 { config_parse_bool, "BOOLEAN" },
3628 { config_parse_string, "STRING" },
3629 { config_parse_path, "PATH" },
3630 { config_parse_unit_path_printf, "PATH" },
3631 { config_parse_strv, "STRING [...]" },
3632 { config_parse_exec_nice, "NICE" },
3633 { config_parse_exec_oom_score_adjust, "OOMSCOREADJUST" },
3634 { config_parse_exec_io_class, "IOCLASS" },
3635 { config_parse_exec_io_priority, "IOPRIORITY" },
3636 { config_parse_exec_cpu_sched_policy, "CPUSCHEDPOLICY" },
3637 { config_parse_exec_cpu_sched_prio, "CPUSCHEDPRIO" },
3638 { config_parse_exec_cpu_affinity, "CPUAFFINITY" },
3639 { config_parse_mode, "MODE" },
3640 { config_parse_unit_env_file, "FILE" },
3641 { config_parse_output, "OUTPUT" },
3642 { config_parse_input, "INPUT" },
3643 { config_parse_log_facility, "FACILITY" },
3644 { config_parse_log_level, "LEVEL" },
3645 { config_parse_exec_capabilities, "CAPABILITIES" },
3646 { config_parse_exec_secure_bits, "SECUREBITS" },
3647 { config_parse_bounding_set, "BOUNDINGSET" },
3648 { config_parse_limit, "LIMIT" },
3649 { config_parse_unit_deps, "UNIT [...]" },
3650 { config_parse_exec, "PATH [ARGUMENT [...]]" },
3651 { config_parse_service_type, "SERVICETYPE" },
3652 { config_parse_service_restart, "SERVICERESTART" },
3653 #ifdef HAVE_SYSV_COMPAT
3654 { config_parse_sysv_priority, "SYSVPRIORITY" },
3655 #endif
3656 { config_parse_kill_mode, "KILLMODE" },
3657 { config_parse_signal, "SIGNAL" },
3658 { config_parse_socket_listen, "SOCKET [...]" },
3659 { config_parse_socket_bind, "SOCKETBIND" },
3660 { config_parse_socket_bindtodevice, "NETWORKINTERFACE" },
3661 { config_parse_sec, "SECONDS" },
3662 { config_parse_nsec, "NANOSECONDS" },
3663 { config_parse_namespace_path_strv, "PATH [...]" },
3664 { config_parse_unit_requires_mounts_for, "PATH [...]" },
3665 { config_parse_exec_mount_flags, "MOUNTFLAG [...]" },
3666 { config_parse_unit_string_printf, "STRING" },
3667 { config_parse_trigger_unit, "UNIT" },
3668 { config_parse_timer, "TIMER" },
3669 { config_parse_path_spec, "PATH" },
3670 { config_parse_notify_access, "ACCESS" },
3671 { config_parse_ip_tos, "TOS" },
3672 { config_parse_unit_condition_path, "CONDITION" },
3673 { config_parse_unit_condition_string, "CONDITION" },
3674 { config_parse_unit_condition_null, "CONDITION" },
3675 { config_parse_unit_slice, "SLICE" },
3676 { config_parse_documentation, "URL" },
3677 { config_parse_service_timeout, "SECONDS" },
3678 { config_parse_failure_action, "ACTION" },
3679 { config_parse_set_status, "STATUS" },
3680 { config_parse_service_sockets, "SOCKETS" },
3681 { config_parse_environ, "ENVIRON" },
3682 #ifdef HAVE_SECCOMP
3683 { config_parse_syscall_filter, "SYSCALLS" },
3684 { config_parse_syscall_archs, "ARCHS" },
3685 { config_parse_syscall_errno, "ERRNO" },
3686 { config_parse_address_families, "FAMILIES" },
3687 #endif
3688 { config_parse_cpu_shares, "SHARES" },
3689 { config_parse_memory_limit, "LIMIT" },
3690 { config_parse_device_allow, "DEVICE" },
3691 { config_parse_device_policy, "POLICY" },
3692 { config_parse_blockio_bandwidth, "BANDWIDTH" },
3693 { config_parse_blockio_weight, "WEIGHT" },
3694 { config_parse_blockio_device_weight, "DEVICEWEIGHT" },
3695 { config_parse_long, "LONG" },
3696 { config_parse_socket_service, "SERVICE" },
3697 #ifdef HAVE_SELINUX
3698 { config_parse_exec_selinux_context, "LABEL" },
3699 #endif
3700 { config_parse_job_mode, "MODE" },
3701 { config_parse_job_mode_isolate, "BOOLEAN" },
3702 { config_parse_personality, "PERSONALITY" },
3703 };
3704
3705 const char *prev = NULL;
3706 const char *i;
3707
3708 assert(f);
3709
3710 NULSTR_FOREACH(i, load_fragment_gperf_nulstr) {
3711 const char *rvalue = "OTHER", *lvalue;
3712 unsigned j;
3713 size_t prefix_len;
3714 const char *dot;
3715 const ConfigPerfItem *p;
3716
3717 assert_se(p = load_fragment_gperf_lookup(i, strlen(i)));
3718
3719 dot = strchr(i, '.');
3720 lvalue = dot ? dot + 1 : i;
3721 prefix_len = dot-i;
3722
3723 if (dot)
3724 if (!prev || !strneq(prev, i, prefix_len+1)) {
3725 if (prev)
3726 fputc('\n', f);
3727
3728 fprintf(f, "[%.*s]\n", (int) prefix_len, i);
3729 }
3730
3731 for (j = 0; j < ELEMENTSOF(table); j++)
3732 if (p->parse == table[j].callback) {
3733 rvalue = table[j].rvalue;
3734 break;
3735 }
3736
3737 fprintf(f, "%s=%s\n", lvalue, rvalue);
3738 prev = i;
3739 }
3740 }
Unnamed repository; edit this file 'description' to name the repository.