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