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