]> git.ipfire.org Git - people/ms/systemd.git/blame - load-fragment.c
projects / people / ms / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
add first_word() call
[people/ms/systemd.git] / load-fragment.c
CommitLineData
3efd4195
LP		 1/*-*- Mode: C; c-basic-offset: 8 -*-*/
2
87f0e418 3#include <linux/oom.h>
3efd4195
LP		 4#include <assert.h>
5#include <errno.h>
6#include <string.h>
87f0e418
LP		 7#include <unistd.h>
8#include <fcntl.h>
3efd4195 9
87f0e418 10#include "unit.h"
3efd4195
LP		 11#include "strv.h"
12#include "conf-parser.h"
13#include "load-fragment.h"
16354eff 14#include "log.h"
9eba9da4 15#include "ioprio.h"
3efd4195 16
42f4e3c4 17static int config_parse_deps(
3efd4195
LP		 18 const char *filename,
19 unsigned line,
20 const char *section,
21 const char *lvalue,
22 const char *rvalue,
23 void *data,
24 void *userdata) {
25
87f0e418
LP		 26 UnitDependency d = PTR_TO_UINT(data);
27 Unit *u = userdata;
3efd4195
LP		 28 char *w;
29 size_t l;
30 char *state;
31
32 assert(filename);
33 assert(lvalue);
34 assert(rvalue);
3efd4195
LP		 35
36 FOREACH_WORD(w, &l, rvalue, state) {
37 char *t;
38 int r;
3efd4195
LP		 39
40 if (!(t = strndup(w, l)))
41 return -ENOMEM;
42
b19e7dc0 43 r = unit_add_dependency_by_name(u, d, t);
3efd4195
LP		 44 free(t);
45
46 if (r < 0)
47 return r;
3efd4195
LP		 48 }
49
50 return 0;
51}
52
42f4e3c4 53static int config_parse_names(
87d1515d
LP		 54 const char *filename,
55 unsigned line,
56 const char *section,
57 const char *lvalue,
58 const char *rvalue,
59 void *data,
60 void *userdata) {
61
87f0e418 62 Unit *u = userdata;
87d1515d
LP		 63 char *w;
64 size_t l;
65 char *state;
66
67 assert(filename);
68 assert(lvalue);
69 assert(rvalue);
70 assert(data);
71
72 FOREACH_WORD(w, &l, rvalue, state) {
73 char *t;
74 int r;
87f0e418 75 Unit *other;
87d1515d
LP		 76
77 if (!(t = strndup(w, l)))
78 return -ENOMEM;
79
87f0e418 80 other = manager_get_unit(u->meta.manager, t);
87d1515d
LP		 81
82 if (other) {
83
87f0e418 84 if (other != u) {
87d1515d 85
87f0e418 86 if (other->meta.load_state != UNIT_STUB) {
87d1515d
LP		 87 free(t);
88 return -EEXIST;
89 }
90
87f0e418 91 if ((r = unit_merge(u, other)) < 0) {
87d1515d
LP		 92 free(t);
93 return r;
94 }
95 }
96
97 } else {
87f0e418 98 if ((r = unit_add_name(u, t)) < 0) {
87d1515d
LP		 99 free(t);
100 return r;
101 }
102 }
103
104 free(t);
105 }
106
107 return 0;
108}
109
42f4e3c4
LP		 110static int config_parse_listen(
111 const char *filename,
112 unsigned line,
113 const char *section,
114 const char *lvalue,
115 const char *rvalue,
116 void *data,
117 void *userdata) {
118
16354eff 119 int r;
542563ba
LP		 120 SocketPort *p;
121 Socket *s;
16354eff 122
42f4e3c4
LP		 123 assert(filename);
124 assert(lvalue);
125 assert(rvalue);
126 assert(data);
127
542563ba
LP		 128 s = (Socket*) data;
129
130 if (!(p = new0(SocketPort, 1)))
131 return -ENOMEM;
132
133 if (streq(lvalue, "ListenFIFO")) {
134 p->type = SOCKET_FIFO;
135
136 if (!(p->path = strdup(rvalue))) {
137 free(p);
138 return -ENOMEM;
139 }
140 } else {
141 p->type = SOCKET_SOCKET;
142
143 if ((r = socket_address_parse(&p->address, rvalue)) < 0) {
144 log_error("[%s:%u] Failed to parse address value: %s", filename, line, rvalue);
145 free(p);
146 return r;
147 }
148
149 if (streq(lvalue, "ListenStream"))
150 p->address.type = SOCK_STREAM;
151 else if (streq(lvalue, "ListenDatagram"))
152 p->address.type = SOCK_DGRAM;
153 else {
154 assert(streq(lvalue, "ListenSequentialPacket"));
155 p->address.type = SOCK_SEQPACKET;
156 }
157
158 if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {
159 free(p);
160 return -EPROTONOSUPPORT;
161 }
16354eff
LP		 162 }
163
542563ba 164 p->fd = -1;
034c6ed7 165 LIST_PREPEND(SocketPort, port, s->ports, p);
542563ba 166
16354eff 167 return 0;
42f4e3c4
LP		 168}
169
034c6ed7 170static int config_parse_socket_bind(
42f4e3c4
LP		 171 const char *filename,
172 unsigned line,
173 const char *section,
174 const char *lvalue,
175 const char *rvalue,
176 void *data,
177 void *userdata) {
178
542563ba
LP		 179 int r;
180 Socket *s;
42f4e3c4
LP		 181
182 assert(filename);
183 assert(lvalue);
184 assert(rvalue);
185 assert(data);
186
542563ba
LP		 187 s = (Socket*) data;
188
189 if ((r = parse_boolean(rvalue)) < 0) {
190 log_error("[%s:%u] Failed to parse bind IPv6 only value: %s", filename, line, rvalue);
191 return r;
16354eff 192 }
42f4e3c4 193
542563ba
LP		 194 s->bind_ipv6_only = r ? SOCKET_ADDRESS_IPV6_ONLY : SOCKET_ADDRESS_BOTH;
195
42f4e3c4
LP		 196 return 0;
197}
198
034c6ed7
LP		 199static int config_parse_nice(
200 const char *filename,
201 unsigned line,
202 const char *section,
203 const char *lvalue,
204 const char *rvalue,
205 void *data,
206 void *userdata) {
207
fb33a393
LP		 208 ExecContext *c = data;
209 int priority, r;
034c6ed7
LP		 210
211 assert(filename);
212 assert(lvalue);
213 assert(rvalue);
214 assert(data);
215
216 if ((r = safe_atoi(rvalue, &priority)) < 0) {
217 log_error("[%s:%u] Failed to parse nice priority: %s", filename, line, rvalue);
218 return r;
219 }
220
221 if (priority < PRIO_MIN || priority >= PRIO_MAX) {
222 log_error("[%s:%u] Nice priority out of range: %s", filename, line, rvalue);
223 return -ERANGE;
224 }
225
fb33a393
LP		 226 c->nice = priority;
227 c->nice_set = false;
228
034c6ed7
LP		 229 return 0;
230}
231
232static int config_parse_oom_adjust(
233 const char *filename,
234 unsigned line,
235 const char *section,
236 const char *lvalue,
237 const char *rvalue,
238 void *data,
239 void *userdata) {
240
fb33a393
LP		 241 ExecContext *c = data;
242 int oa, r;
034c6ed7
LP		 243
244 assert(filename);
245 assert(lvalue);
246 assert(rvalue);
247 assert(data);
248
249 if ((r = safe_atoi(rvalue, &oa)) < 0) {
250 log_error("[%s:%u] Failed to parse OOM adjust value: %s", filename, line, rvalue);
251 return r;
252 }
253
254 if (oa < OOM_DISABLE || oa > OOM_ADJUST_MAX) {
255 log_error("[%s:%u] OOM adjust value out of range: %s", filename, line, rvalue);
256 return -ERANGE;
257 }
258
fb33a393
LP		 259 c->oom_adjust = oa;
260 c->oom_adjust_set = true;
261
034c6ed7
LP		 262 return 0;
263}
264
265static int config_parse_umask(
266 const char *filename,
267 unsigned line,
268 const char *section,
269 const char *lvalue,
270 const char *rvalue,
271 void *data,
272 void *userdata) {
273
274 mode_t *m = data;
275 long l;
276 char *x = NULL;
277
278 assert(filename);
279 assert(lvalue);
280 assert(rvalue);
281 assert(data);
282
283 errno = 0;
284 l = strtol(rvalue, &x, 8);
285 if (!x || *x || errno) {
286 log_error("[%s:%u] Failed to parse umask value: %s", filename, line, rvalue);
287 return errno ? -errno : -EINVAL;
288 }
289
290 if (l < 0000 || l > 0777) {
291 log_error("[%s:%u] umask value out of range: %s", filename, line, rvalue);
292 return -ERANGE;
293 }
294
295 *m = (mode_t) l;
296 return 0;
297}
298
299static int config_parse_exec(
300 const char *filename,
301 unsigned line,
302 const char *section,
303 const char *lvalue,
304 const char *rvalue,
305 void *data,
306 void *userdata) {
307
308 ExecCommand **e = data, *ee, *nce = NULL;
309 char **n;
310 char *w;
311 unsigned k;
312 size_t l;
313 char *state;
314
315 assert(filename);
316 assert(lvalue);
317 assert(rvalue);
318 assert(data);
319
320 k = 0;
321 FOREACH_WORD_QUOTED(w, l, rvalue, state)
322 k++;
323
324 if (!(n = new(char*, k+1)))
325 return -ENOMEM;
326
44d8db9e 327 k = 0;
034c6ed7
LP		 328 FOREACH_WORD_QUOTED(w, l, rvalue, state)
329 if (!(n[k++] = strndup(w, l)))
330 goto fail;
331
332 n[k] = NULL;
333
0301abf4 334 if (!n[0] || !path_is_absolute(n[0])) {
034c6ed7
LP		 335 log_error("[%s:%u] Invalid executable path in command line: %s", filename, line, rvalue);
336 strv_free(n);
337 return -EINVAL;
338 }
339
340 if (!(nce = new0(ExecCommand, 1)))
341 goto fail;
342
343 nce->argv = n;
344 if (!(nce->path = strdup(n[0])))
345 goto fail;
346
347 if (*e) {
348 /* It's kinda important that we keep the order here */
349 LIST_FIND_TAIL(ExecCommand, command, *e, ee);
350 LIST_INSERT_AFTER(ExecCommand, command, *e, ee, nce);
351 } else
352 *e = nce;
353
354 return 0;
355
356fail:
357 for (; k > 0; k--)
358 free(n[k-1]);
359 free(n);
360
361 free(nce);
362
363 return -ENOMEM;
364}
365
366static int config_parse_usec(
367 const char *filename,
368 unsigned line,
369 const char *section,
370 const char *lvalue,
371 const char *rvalue,
372 void *data,
373 void *userdata) {
374
375 usec_t *usec = data;
376 unsigned long long u;
377 int r;
378
379 assert(filename);
380 assert(lvalue);
381 assert(rvalue);
382 assert(data);
383
384 if ((r = safe_atollu(rvalue, &u)) < 0) {
385 log_error("[%s:%u] Failed to parse time value: %s", filename, line, rvalue);
386 return r;
387 }
388
389 /* We actually assume the user configures seconds. Later on we
390 * might choose to support suffixes for time values, to
391 * configure bigger or smaller units */
392
393 *usec = u * USEC_PER_SEC;
394
395 return 0;
396}
397
398static int config_parse_service_type(
399 const char *filename,
400 unsigned line,
401 const char *section,
402 const char *lvalue,
403 const char *rvalue,
404 void *data,
405 void *userdata) {
406
407 Service *s = data;
408
409 assert(filename);
410 assert(lvalue);
411 assert(rvalue);
412 assert(data);
413
414 if (streq(rvalue, "forking"))
415 s->type = SERVICE_FORKING;
416 else if (streq(rvalue, "simple"))
417 s->type = SERVICE_SIMPLE;
418 else {
419 log_error("[%s:%u] Failed to parse service type: %s", filename, line, rvalue);
420 return -EBADMSG;
421 }
422
423 return 0;
424}
425
426static int config_parse_service_restart(
427 const char *filename,
428 unsigned line,
429 const char *section,
430 const char *lvalue,
431 const char *rvalue,
432 void *data,
433 void *userdata) {
434
435 Service *s = data;
436
437 assert(filename);
438 assert(lvalue);
439 assert(rvalue);
440 assert(data);
441
442 if (streq(rvalue, "once"))
443 s->restart = SERVICE_ONCE;
444 else if (streq(rvalue, "on-success"))
445 s->type = SERVICE_RESTART_ON_SUCCESS;
446 else if (streq(rvalue, "always"))
447 s->type = SERVICE_RESTART_ALWAYS;
448 else {
449 log_error("[%s:%u] Failed to parse service type: %s", filename, line, rvalue);
450 return -EBADMSG;
451 }
452
453 return 0;
454}
455
acbb0225
LP		 456int config_parse_bindtodevice(
457 const char *filename,
458 unsigned line,
459 const char *section,
460 const char *lvalue,
461 const char *rvalue,
462 void *data,
463 void *userdata) {
464
465 Socket *s = data;
466 char *n;
467
468 assert(filename);
469 assert(lvalue);
470 assert(rvalue);
471 assert(data);
472
473 if (rvalue[0] && !streq(rvalue, "*")) {
474 if (!(n = strdup(rvalue)))
475 return -ENOMEM;
476 } else
477 n = NULL;
478
479 free(s->bind_to_device);
480 s->bind_to_device = n;
481
482 return 0;
483}
484
071830ff
LP		 485int config_parse_output(
486 const char *filename,
487 unsigned line,
488 const char *section,
489 const char *lvalue,
490 const char *rvalue,
491 void *data,
492 void *userdata) {
493
494 ExecOutput *o = data;
495
496 assert(filename);
497 assert(lvalue);
498 assert(rvalue);
499 assert(data);
500
501 if (streq(rvalue, "syslog"))
502 *o = EXEC_SYSLOG;
503 else if (streq(rvalue, "null"))
504 *o = EXEC_NULL;
505 else if (streq(rvalue, "syslog"))
506 *o = EXEC_SYSLOG;
507 else if (streq(rvalue, "kernel"))
508 *o = EXEC_KERNEL;
509 else {
510 log_error("[%s:%u] Failed to parse log output: %s", filename, line, rvalue);
511 return -EBADMSG;
512 }
513
514 return 0;
515}
87f0e418 516
071830ff
LP		 517int config_parse_facility(
518 const char *filename,
519 unsigned line,
520 const char *section,
521 const char *lvalue,
522 const char *rvalue,
523 void *data,
524 void *userdata) {
525
526 static const char * const table[LOG_NFACILITIES] = {
527 [LOG_FAC(LOG_KERN)] = "kern",
528 [LOG_FAC(LOG_USER)] = "user",
529 [LOG_FAC(LOG_MAIL)] = "mail",
530 [LOG_FAC(LOG_DAEMON)] = "daemon",
531 [LOG_FAC(LOG_AUTH)] = "auth",
532 [LOG_FAC(LOG_SYSLOG)] = "syslog",
533 [LOG_FAC(LOG_LPR)] = "lpr",
534 [LOG_FAC(LOG_NEWS)] = "news",
535 [LOG_FAC(LOG_UUCP)] = "uucp",
536 [LOG_FAC(LOG_CRON)] = "cron",
537 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
538 [LOG_FAC(LOG_FTP)] = "ftp",
539 [LOG_FAC(LOG_LOCAL0)] = "local0",
540 [LOG_FAC(LOG_LOCAL1)] = "local1",
541 [LOG_FAC(LOG_LOCAL2)] = "local2",
542 [LOG_FAC(LOG_LOCAL3)] = "local3",
543 [LOG_FAC(LOG_LOCAL4)] = "local4",
544 [LOG_FAC(LOG_LOCAL5)] = "local5",
545 [LOG_FAC(LOG_LOCAL6)] = "local6",
546 [LOG_FAC(LOG_LOCAL7)] = "local7"
547 };
548
549 ExecOutput *o = data;
550 int i;
551
552 assert(filename);
553 assert(lvalue);
554 assert(rvalue);
555 assert(data);
556
557 for (i = 0; i < (int) ELEMENTSOF(table); i++)
558 if (streq(rvalue, table[i])) {
559 *o = LOG_MAKEPRI(i, LOG_PRI(*o));
560 break;
561 }
562
563 if (i >= (int) ELEMENTSOF(table)) {
564
565 /* Second try, let's see if this is a number. */
566 if (safe_atoi(rvalue, &i) >= 0 &&
567 i >= 0 &&
568 i < (int) ELEMENTSOF(table))
569 *o = LOG_MAKEPRI(i, LOG_PRI(*o));
570 else {
571 log_error("[%s:%u] Failed to parse log output: %s", filename, line, rvalue);
572 return -EBADMSG;
573 }
574 }
575
576 return 0;
577}
578
579int config_parse_level(
580 const char *filename,
581 unsigned line,
582 const char *section,
583 const char *lvalue,
584 const char *rvalue,
585 void *data,
586 void *userdata) {
587
588 static const char * const table[LOG_DEBUG+1] = {
589 [LOG_EMERG] = "emerg",
590 [LOG_ALERT] = "alert",
591 [LOG_CRIT] = "crit",
592 [LOG_ERR] = "err",
593 [LOG_WARNING] = "warning",
594 [LOG_NOTICE] = "notice",
595 [LOG_INFO] = "info",
596 [LOG_DEBUG] = "debug"
597 };
598
599 ExecOutput *o = data;
600 int i;
601
602 assert(filename);
603 assert(lvalue);
604 assert(rvalue);
605 assert(data);
606
607 for (i = 0; i < (int) ELEMENTSOF(table); i++)
608 if (streq(rvalue, table[i])) {
609 *o = LOG_MAKEPRI(LOG_FAC(*o), i);
610 break;
611 }
612
613 if (i >= LOG_NFACILITIES) {
614
615 /* Second try, let's see if this is a number. */
616 if (safe_atoi(rvalue, &i) >= 0 &&
617 i >= 0 &&
618 i < (int) ELEMENTSOF(table))
619 *o = LOG_MAKEPRI(LOG_FAC(*o), i);
620 else {
621 log_error("[%s:%u] Failed to parse log output: %s", filename, line, rvalue);
622 return -EBADMSG;
623 }
624 }
625
626 return 0;
627}
628
9eba9da4
LP		 629int config_parse_io_class(
630 const char *filename,
631 unsigned line,
632 const char *section,
633 const char *lvalue,
634 const char *rvalue,
635 void *data,
636 void *userdata) {
637
638 static const char * const table[] = {
639 [IOPRIO_CLASS_NONE] = NULL,
640 [IOPRIO_CLASS_RT] = "realtime",
641 [IOPRIO_CLASS_BE] = "best-effort",
642 [IOPRIO_CLASS_IDLE] = "idle",
643 };
644
645 ExecContext *c = data;
646 int i;
647
648 assert(filename);
649 assert(lvalue);
650 assert(rvalue);
651 assert(data);
652
653 for (i = 0; i < (int) ELEMENTSOF(table); i++) {
654 if (!table[i])
655 continue;
656
657 if (streq(rvalue, table[i])) {
658 c->ioprio = IOPRIO_PRIO_VALUE(i, IOPRIO_PRIO_DATA(c->ioprio));
659 break;
660 }
661 }
662
663 if (i >= (int) ELEMENTSOF(table)) {
664
665 /* Second try, let's see if this is a number. */
666 if (safe_atoi(rvalue, &i) >= 0 &&
667 i >= 0 &&
668 i < (int) ELEMENTSOF(table) &&
669 table[i])
670 c->ioprio = IOPRIO_PRIO_VALUE(i, IOPRIO_PRIO_DATA(c->ioprio));
671 else {
672 log_error("[%s:%u] Failed to parse io priority: %s", filename, line, rvalue);
673 return -EBADMSG;
674 }
675 }
676
677 c->ioprio_set = true;
678
679 return 0;
680}
681
682int config_parse_io_priority(
683 const char *filename,
684 unsigned line,
685 const char *section,
686 const char *lvalue,
687 const char *rvalue,
688 void *data,
689 void *userdata) {
690
691 ExecContext *c = data;
692 int i;
693
694 assert(filename);
695 assert(lvalue);
696 assert(rvalue);
697 assert(data);
698
699 if (safe_atoi(rvalue, &i) >= 0 &&
700 i >= 0 &&
701 i < IOPRIO_BE_NR)
702 c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_PRIO_CLASS(c->ioprio), i);
703 else {
704 log_error("[%s:%u] Failed to parse io priority: %s", filename, line, rvalue);
705 return -EBADMSG;
706 }
707
708 c->ioprio_set = true;
709
710 return 0;
711}
712
071830ff 713#define FOLLOW_MAX 8
87f0e418 714
0301abf4
LP		 715static int open_follow(char **filename, FILE **_f, Set *names, char **_id) {
716 unsigned c = 0;
87f0e418
LP		 717 int fd, r;
718 FILE *f;
0301abf4 719 char *id = NULL;
87f0e418
LP		 720
721 assert(filename);
722 assert(*filename);
723 assert(_f);
724 assert(names);
725
0301abf4
LP		 726 /* This will update the filename pointer if the loaded file is
727 * reached by a symlink. The old string will be freed. */
87f0e418 728
0301abf4 729 for (;;) {
87f0e418
LP		 730 char *target, *k, *name;
731
0301abf4
LP		 732 if (c++ >= FOLLOW_MAX)
733 return -ELOOP;
734
b08d03ff
LP		 735 path_kill_slashes(*filename);
736
87f0e418
LP		 737 /* Add the file name we are currently looking at to
738 * the names of this unit */
0301abf4
LP		 739 name = file_name_from_path(*filename);
740 if (!(id = set_get(names, name))) {
87f0e418 741
0301abf4
LP		 742 if (!(id = strdup(name)))
743 return -ENOMEM;
87f0e418 744
0301abf4
LP		 745 if ((r = set_put(names, id)) < 0) {
746 free(id);
747 return r;
87f0e418 748 }
87f0e418
LP		 749 }
750
0301abf4
LP		 751 /* Try to open the file name, but don't if its a symlink */
752 if ((fd = open(*filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW)) >= 0)
87f0e418
LP		 753 break;
754
0301abf4
LP		 755 if (errno != ELOOP)
756 return -errno;
757
87f0e418 758 /* Hmm, so this is a symlink. Let's read the name, and follow it manually */
0301abf4
LP		 759 if ((r = readlink_malloc(*filename, &target)) < 0)
760 return r;
87f0e418 761
c25fb0ed 762 k = file_in_same_dir(*filename, target);
87f0e418
LP		 763 free(target);
764
0301abf4
LP		 765 if (!k)
766 return -ENOMEM;
87f0e418 767
0301abf4
LP		 768 free(*filename);
769 *filename = k;
87f0e418
LP		 770 }
771
772 if (!(f = fdopen(fd, "r"))) {
773 r = -errno;
774 assert(close_nointr(fd) == 0);
0301abf4 775 return r;
87f0e418
LP		 776 }
777
778 *_f = f;
0301abf4
LP		 779 *_id = id;
780 return 0;
87f0e418
LP		 781}
782
0301abf4 783static int load_from_path(Unit *u, const char *path) {
87f0e418
LP		 784
785 static const char* const section_table[_UNIT_TYPE_MAX] = {
786 [UNIT_SERVICE] = "Service",
787 [UNIT_TIMER] = "Timer",
788 [UNIT_SOCKET] = "Socket",
789 [UNIT_TARGET] = "Target",
790 [UNIT_DEVICE] = "Device",
791 [UNIT_MOUNT] = "Mount",
792 [UNIT_AUTOMOUNT] = "Automount",
793 [UNIT_SNAPSHOT] = "Snapshot"
42f4e3c4
LP		 794 };
795
034c6ed7 796#define EXEC_CONTEXT_CONFIG_ITEMS(context, section) \
9eba9da4
LP		 797 { "WorkingDirectory", config_parse_path, &(context).working_directory, section }, \
798 { "RootDirectory", config_parse_path, &(context).root_directory, section }, \
1c01f82b
LP		 799 { "User", config_parse_string, &(context).user, section }, \
800 { "Group", config_parse_string, &(context).group, section }, \
801 { "SupplementaryGroups", config_parse_strv, &(context).supplementary_groups, section }, \
fb33a393
LP		 802 { "Nice", config_parse_nice, &(context), section }, \
803 { "OOMAdjust", config_parse_oom_adjust, &(context), section }, \
9eba9da4
LP		 804 { "IOPriority", config_parse_io_priority, &(context), section }, \
805 { "IOSchedulingClass", config_parse_io_class, &(context), section }, \
1c01f82b 806 { "UMask", config_parse_umask, &(context).umask, section }, \
071830ff
LP		 807 { "Environment", config_parse_strv, &(context).environment, section }, \
808 { "Output", config_parse_output, &(context).output, section }, \
809 { "SyslogIdentifier", config_parse_string, &(context).syslog_identifier, section }, \
810 { "SyslogFacility", config_parse_facility, &(context).syslog_priority, section }, \
811 { "SyslogLevel", config_parse_level, &(context).syslog_priority, section }
034c6ed7 812
3efd4195 813 const ConfigItem items[] = {
1c01f82b
LP		 814 { "Names", config_parse_names, u, "Meta" },
815 { "Description", config_parse_string, &u->meta.description, "Meta" },
816 { "Requires", config_parse_deps, UINT_TO_PTR(UNIT_REQUIRES), "Meta" },
817 { "SoftRequires", config_parse_deps, UINT_TO_PTR(UNIT_SOFT_REQUIRES), "Meta" },
818 { "Wants", config_parse_deps, UINT_TO_PTR(UNIT_WANTS), "Meta" },
819 { "Requisite", config_parse_deps, UINT_TO_PTR(UNIT_REQUISITE), "Meta" },
820 { "SoftRequisite", config_parse_deps, UINT_TO_PTR(UNIT_SOFT_REQUISITE), "Meta" },
821 { "Conflicts", config_parse_deps, UINT_TO_PTR(UNIT_CONFLICTS), "Meta" },
822 { "Before", config_parse_deps, UINT_TO_PTR(UNIT_BEFORE), "Meta" },
823 { "After", config_parse_deps, UINT_TO_PTR(UNIT_AFTER), "Meta" },
f3bff0eb
LP		 824 { "RecursiveStop", config_parse_bool, &u->meta.recursive_stop, "Meta" },
825 { "StopWhenUnneeded", config_parse_bool, &u->meta.stop_when_unneeded, "Meta" },
1c01f82b
LP		 826
827 { "PIDFile", config_parse_path, &u->service.pid_file, "Service" },
828 { "ExecStartPre", config_parse_exec, u->service.exec_command+SERVICE_EXEC_START_PRE, "Service" },
829 { "ExecStart", config_parse_exec, u->service.exec_command+SERVICE_EXEC_START, "Service" },
830 { "ExecStartPost", config_parse_exec, u->service.exec_command+SERVICE_EXEC_START_POST, "Service" },
831 { "ExecReload", config_parse_exec, u->service.exec_command+SERVICE_EXEC_RELOAD, "Service" },
832 { "ExecStop", config_parse_exec, u->service.exec_command+SERVICE_EXEC_STOP, "Service" },
833 { "ExecStopPost", config_parse_exec, u->service.exec_command+SERVICE_EXEC_STOP_POST, "Service" },
834 { "RestartSec", config_parse_usec, &u->service.restart_usec, "Service" },
835 { "TimeoutSec", config_parse_usec, &u->service.timeout_usec, "Service" },
836 { "Type", config_parse_service_type, &u->service, "Service" },
837 { "Restart", config_parse_service_restart, &u->service, "Service" },
87f0e418
LP		 838 EXEC_CONTEXT_CONFIG_ITEMS(u->service.exec_context, "Service"),
839
1c01f82b
LP		 840 { "ListenStream", config_parse_listen, &u->socket, "Socket" },
841 { "ListenDatagram", config_parse_listen, &u->socket, "Socket" },
842 { "ListenSequentialPacket", config_parse_listen, &u->socket, "Socket" },
843 { "ListenFIFO", config_parse_listen, &u->socket, "Socket" },
844 { "BindIPv6Only", config_parse_socket_bind, &u->socket, "Socket" },
845 { "Backlog", config_parse_unsigned, &u->socket.backlog, "Socket" },
acbb0225 846 { "BindToDevice", config_parse_bindtodevice, &u->socket, "Socket" },
1c01f82b
LP		 847 { "ExecStartPre", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_START_PRE, "Socket" },
848 { "ExecStartPost", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_START_POST, "Socket" },
849 { "ExecStopPre", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_STOP_PRE, "Socket" },
850 { "ExecStopPost", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_STOP_POST, "Socket" },
87f0e418
LP		 851 EXEC_CONTEXT_CONFIG_ITEMS(u->socket.exec_context, "Socket"),
852
853 EXEC_CONTEXT_CONFIG_ITEMS(u->automount.exec_context, "Automount"),
034c6ed7 854
3efd4195
LP		 855 { NULL, NULL, NULL, NULL }
856 };
857
034c6ed7 858#undef EXEC_CONTEXT_CONFIG_ITEMS
42f4e3c4 859
42f4e3c4 860 const char *sections[3];
0301abf4
LP		 861 char *k;
862 int r;
87f0e418 863 Set *symlink_names;
0301abf4
LP		 864 FILE *f;
865 char *filename, *id;
3efd4195 866
42f4e3c4 867 sections[0] = "Meta";
87f0e418 868 sections[1] = section_table[u->meta.type];
42f4e3c4
LP		 869 sections[2] = NULL;
870
87f0e418
LP		 871 if (!(symlink_names = set_new(string_hash_func, string_compare_func)))
872 return -ENOMEM;
3efd4195 873
0301abf4
LP		 874 /* Instead of opening the path right away, we manually
875 * follow all symlinks and add their name to our unit
876 * name set while doing so */
877 if (!(filename = path_make_absolute(path, unit_path()))) {
878 r = -ENOMEM;
879 goto finish;
880 }
3efd4195 881
0301abf4
LP		 882 if ((r = open_follow(&filename, &f, symlink_names, &id)) < 0) {
883 if (r == -ENOENT)
884 r = 0; /* returning 0 means: no suitable config file found */
034c6ed7 885
0301abf4
LP		 886 goto finish;
887 }
87f0e418 888
0301abf4
LP		 889 /* Now, parse the file contents */
890 r = config_parse(filename, f, sections, items, u);
891 if (r < 0)
892 goto finish;
87f0e418 893
0301abf4
LP		 894 /* Let's try to add in all symlink names we found */
895 while ((k = set_steal_first(symlink_names))) {
896 if ((r = unit_add_name(u, k)) < 0)
87f0e418
LP		 897 goto finish;
898
87f0e418 899
f50e0a01
LP		 900 if (id == k)
901 unit_choose_id(u, id);
0301abf4 902 free(k);
034c6ed7
LP		 903 }
904
b08d03ff 905
0301abf4
LP		 906 free(u->meta.load_path);
907 u->meta.load_path = filename;
908 filename = NULL;
87f0e418 909
0301abf4 910 r = 1; /* returning 1 means: suitable config file found and loaded */
87f0e418
LP		 911
912finish:
913 while ((k = set_steal_first(symlink_names)))
914 free(k);
87f0e418 915 set_free(symlink_names);
0301abf4
LP		 916 free(filename);
917
918 return r;
919}
920
921int unit_load_fragment(Unit *u) {
d46de8a1 922 int r = 0;
071830ff 923 ExecContext *c;
0301abf4
LP		 924
925 assert(u);
926 assert(u->meta.load_state == UNIT_STUB);
927
928 if (u->meta.load_path)
929 r = load_from_path(u, u->meta.load_path);
930 else {
931 Iterator i;
932 char *t;
933
934 /* Try to find a name we can load this with */
935 SET_FOREACH(t, u->meta.names, i)
936 if ((r = load_from_path(u, t)) != 0)
937 return r;
938 }
87f0e418 939
071830ff
LP		 940 if (u->meta.type == UNIT_SOCKET)
941 c = &u->socket.exec_context;
942 else if (u->meta.type == UNIT_SERVICE)
943 c = &u->service.exec_context;
944 else
945 c = NULL;
946
947 if (r >= 0 && c &&
948 (c->output == EXEC_KERNEL || c->output == EXEC_SYSLOG)) {
d46de8a1
LP		 949 int k;
950
071830ff
LP		 951 /* If syslog or kernel logging is requested, make sure
952 * our own logging daemon is run first. */
953
f50e0a01 954 if ((k = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_LOGGER_SOCKET)) < 0)
d46de8a1 955 return k;
071830ff 956
f50e0a01 957 if ((k = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_LOGGER_SOCKET)) < 0)
d46de8a1 958 return k;
071830ff
LP		 959 }
960
87f0e418 961 return r;
3efd4195 962}
Michael's branch of systemd.