src/shared/conf-parser.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 <string.h>
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <assert.h>
  26 #include <stdlib.h>
  27 #include <netinet/ether.h>
  28
  29 #include "conf-parser.h"
  30 #include "util.h"
  31 #include "macro.h"
  32 #include "strv.h"
  33 #include "log.h"
  34 #include "utf8.h"
  35 #include "path-util.h"
  36 #include "set.h"
  37 #include "exit-status.h"
  38 #include "sd-messages.h"
  39
  40 int log_syntax_internal(const char *unit, int level,
  41                         const char *file, unsigned line, const char *func,
  42                         const char *config_file, unsigned config_line,
  43                         int error, const char *format, ...) {
  44
  45         _cleanup_free_ char *msg = NULL;
  46         int r;
  47         va_list ap;
  48
  49         va_start(ap, format);
  50         r = vasprintf(&msg, format, ap);
  51         va_end(ap);
  52         if (r < 0)
  53                 return log_oom();
  54
  55         if (unit)
  56                 r = log_struct_internal(level,
  57                                         file, line, func,
  58                                         getpid() == 1 ? "UNIT=%s" : "USER_UNIT=%s", unit,
  59                                         MESSAGE_ID(SD_MESSAGE_CONFIG_ERROR),
  60                                         "CONFIG_FILE=%s", config_file,
  61                                         "CONFIG_LINE=%u", config_line,
  62                                         "ERRNO=%d", error > 0 ? error : EINVAL,
  63                                         "MESSAGE=[%s:%u] %s", config_file, config_line, msg,
  64                                         NULL);
  65         else
  66                 r = log_struct_internal(level,
  67                                         file, line, func,
  68                                         MESSAGE_ID(SD_MESSAGE_CONFIG_ERROR),
  69                                         "CONFIG_FILE=%s", config_file,
  70                                         "CONFIG_LINE=%u", config_line,
  71                                         "ERRNO=%d", error > 0 ? error : EINVAL,
  72                                         "MESSAGE=[%s:%u] %s", config_file, config_line, msg,
  73                                         NULL);
  74
  75         return r;
  76 }
  77
  78 int config_item_table_lookup(
  79                 void *table,
  80                 const char *section,
  81                 const char *lvalue,
  82                 ConfigParserCallback *func,
  83                 int *ltype,
  84                 void **data,
  85                 void *userdata) {
  86
  87         ConfigTableItem *t;
  88
  89         assert(table);
  90         assert(lvalue);
  91         assert(func);
  92         assert(ltype);
  93         assert(data);
  94
  95         for (t = table; t->lvalue; t++) {
  96
  97                 if (!streq(lvalue, t->lvalue))
  98                         continue;
  99
 100                 if (!streq_ptr(section, t->section))
 101                         continue;
 102
 103                 *func = t->parse;
 104                 *ltype = t->ltype;
 105                 *data = t->data;
 106                 return 1;
 107         }
 108
 109         return 0;
 110 }
 111
 112 int config_item_perf_lookup(
 113                 void *table,
 114                 const char *section,
 115                 const char *lvalue,
 116                 ConfigParserCallback *func,
 117                 int *ltype,
 118                 void **data,
 119                 void *userdata) {
 120
 121         ConfigPerfItemLookup lookup = (ConfigPerfItemLookup) table;
 122         const ConfigPerfItem *p;
 123
 124         assert(table);
 125         assert(lvalue);
 126         assert(func);
 127         assert(ltype);
 128         assert(data);
 129
 130         if (!section)
 131                 p = lookup(lvalue, strlen(lvalue));
 132         else {
 133                 char *key;
 134
 135                 key = strjoin(section, ".", lvalue, NULL);
 136                 if (!key)
 137                         return -ENOMEM;
 138
 139                 p = lookup(key, strlen(key));
 140                 free(key);
 141         }
 142
 143         if (!p)
 144                 return 0;
 145
 146         *func = p->parse;
 147         *ltype = p->ltype;
 148         *data = (uint8_t*) userdata + p->offset;
 149         return 1;
 150 }
 151
 152 /* Run the user supplied parser for an assignment */
 153 static int next_assignment(const char *unit,
 154                            const char *filename,
 155                            unsigned line,
 156                            ConfigItemLookup lookup,
 157                            void *table,
 158                            const char *section,
 159                            unsigned section_line,
 160                            const char *lvalue,
 161                            const char *rvalue,
 162                            bool relaxed,
 163                            void *userdata) {
 164
 165         ConfigParserCallback func = NULL;
 166         int ltype = 0;
 167         void *data = NULL;
 168         int r;
 169
 170         assert(filename);
 171         assert(line > 0);
 172         assert(lookup);
 173         assert(lvalue);
 174         assert(rvalue);
 175
 176         r = lookup(table, section, lvalue, &func, &ltype, &data, userdata);
 177         if (r < 0)
 178                 return r;
 179
 180         if (r > 0) {
 181                 if (func)
 182                         return func(unit, filename, line, section, section_line,
 183                                     lvalue, ltype, rvalue, data, userdata);
 184
 185                 return 0;
 186         }
 187
 188         /* Warn about unknown non-extension fields. */
 189         if (!relaxed && !startswith(lvalue, "X-"))
 190                 log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
 191                            "Unknown lvalue '%s' in section '%s'", lvalue, section);
 192
 193         return 0;
 194 }
 195
 196 /* Parse a variable assignment line */
 197 static int parse_line(const char* unit,
 198                       const char *filename,
 199                       unsigned line,
 200                       const char *sections,
 201                       ConfigItemLookup lookup,
 202                       void *table,
 203                       bool relaxed,
 204                       bool allow_include,
 205                       char **section,
 206                       unsigned *section_line,
 207                       char *l,
 208                       void *userdata) {
 209
 210         char *e;
 211
 212         assert(filename);
 213         assert(line > 0);
 214         assert(lookup);
 215         assert(l);
 216
 217         l = strstrip(l);
 218
 219         if (!*l)
 220                 return 0;
 221
 222         if (strchr(COMMENTS "\n", *l))
 223                 return 0;
 224
 225         if (startswith(l, ".include ")) {
 226                 _cleanup_free_ char *fn = NULL;
 227
 228                 if (!allow_include) {
 229                         log_syntax(unit, LOG_ERR, filename, line, EBADMSG,
 230                                    ".include not allowed here. Ignoring.");
 231                         return 0;
 232                 }
 233
 234                 fn = file_in_same_dir(filename, strstrip(l+9));
 235                 if (!fn)
 236                         return -ENOMEM;
 237
 238                 return config_parse(unit, fn, NULL, sections, lookup, table, relaxed, false, userdata);
 239         }
 240
 241         if (*l == '[') {
 242                 size_t k;
 243                 char *n;
 244
 245                 k = strlen(l);
 246                 assert(k > 0);
 247
 248                 if (l[k-1] != ']') {
 249                         log_syntax(unit, LOG_ERR, filename, line, EBADMSG,
 250                                    "Invalid section header '%s'", l);
 251                         return -EBADMSG;
 252                 }
 253
 254                 n = strndup(l+1, k-2);
 255                 if (!n)
 256                         return -ENOMEM;
 257
 258                 if (sections && !nulstr_contains(sections, n)) {
 259
 260                         if (!relaxed)
 261                                 log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
 262                                            "Unknown section '%s'. Ignoring.", n);
 263
 264                         free(n);
 265                         free(*section);
 266                         *section = NULL;
 267                         *section_line = 0;
 268                 } else {
 269                         free(*section);
 270                         *section = n;
 271                         *section_line = line;
 272                 }
 273
 274                 return 0;
 275         }
 276
 277         if (sections && !*section) {
 278
 279                 if (!relaxed)
 280                         log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
 281                                    "Assignment outside of section. Ignoring.");
 282
 283                 return 0;
 284         }
 285
 286         e = strchr(l, '=');
 287         if (!e) {
 288                 log_syntax(unit, LOG_WARNING, filename, line, EINVAL, "Missing '='.");
 289                 return -EBADMSG;
 290         }
 291
 292         *e = 0;
 293         e++;
 294
 295         return next_assignment(unit,
 296                                filename,
 297                                line,
 298                                lookup,
 299                                table,
 300                                *section,
 301                                *section_line,
 302                                strstrip(l),
 303                                strstrip(e),
 304                                relaxed,
 305                                userdata);
 306 }
 307
 308 /* Go through the file and parse each line */
 309 int config_parse(const char *unit,
 310                  const char *filename,
 311                  FILE *f,
 312                  const char *sections,
 313                  ConfigItemLookup lookup,
 314                  void *table,
 315                  bool relaxed,
 316                  bool allow_include,
 317                  void *userdata) {
 318
 319         _cleanup_free_ char *section = NULL, *continuation = NULL;
 320         _cleanup_fclose_ FILE *ours = NULL;
 321         unsigned line = 0, section_line = 0;
 322         int r;
 323
 324         assert(filename);
 325         assert(lookup);
 326
 327         if (!f) {
 328                 f = ours = fopen(filename, "re");
 329                 if (!f) {
 330                         log_error("Failed to open configuration file '%s': %m", filename);
 331                         return -errno;
 332                 }
 333         }
 334
 335         fd_warn_permissions(filename, fileno(f));
 336
 337         while (!feof(f)) {
 338                 char l[LINE_MAX], *p, *c = NULL, *e;
 339                 bool escaped = false;
 340
 341                 if (!fgets(l, sizeof(l), f)) {
 342                         if (feof(f))
 343                                 break;
 344
 345                         log_error("Failed to read configuration file '%s': %m", filename);
 346                         return -errno;
 347                 }
 348
 349                 truncate_nl(l);
 350
 351                 if (continuation) {
 352                         c = strappend(continuation, l);
 353                         if (!c)
 354                                 return -ENOMEM;
 355
 356                         free(continuation);
 357                         continuation = NULL;
 358                         p = c;
 359                 } else
 360                         p = l;
 361
 362                 for (e = p; *e; e++) {
 363                         if (escaped)
 364                                 escaped = false;
 365                         else if (*e == '\\')
 366                                 escaped = true;
 367                 }
 368
 369                 if (escaped) {
 370                         *(e-1) = ' ';
 371
 372                         if (c)
 373                                 continuation = c;
 374                         else {
 375                                 continuation = strdup(l);
 376                                 if (!continuation)
 377                                         return -ENOMEM;
 378                         }
 379
 380                         continue;
 381                 }
 382
 383                 r = parse_line(unit,
 384                                filename,
 385                                ++line,
 386                                sections,
 387                                lookup,
 388                                table,
 389                                relaxed,
 390                                allow_include,
 391                                &section,
 392                                &section_line,
 393                                p,
 394                                userdata);
 395                 free(c);
 396
 397                 if (r < 0)
 398                         return r;
 399         }
 400
 401         return 0;
 402 }
 403
 404 #define DEFINE_PARSER(type, vartype, conv_func)                         \
 405         int config_parse_##type(const char *unit,                       \
 406                                 const char *filename,                   \
 407                                 unsigned line,                          \
 408                                 const char *section,                    \
 409                                 unsigned section_line,                  \
 410                                 const char *lvalue,                     \
 411                                 int ltype,                              \
 412                                 const char *rvalue,                     \
 413                                 void *data,                             \
 414                                 void *userdata) {                       \
 415                                                                         \
 416                 vartype *i = data;                                      \
 417                 int r;                                                  \
 418                                                                         \
 419                 assert(filename);                                       \
 420                 assert(lvalue);                                         \
 421                 assert(rvalue);                                         \
 422                 assert(data);                                           \
 423                                                                         \
 424                 r = conv_func(rvalue, i);                               \
 425                 if (r < 0)                                              \
 426                         log_syntax(unit, LOG_ERR, filename, line, -r,   \
 427                                    "Failed to parse %s value, ignoring: %s", \
 428                                    #vartype, rvalue);                   \
 429                                                                         \
 430                 return 0;                                               \
 431         }
 432
 433 DEFINE_PARSER(int, int, safe_atoi)
 434 DEFINE_PARSER(long, long, safe_atoli)
 435 DEFINE_PARSER(uint64, uint64_t, safe_atou64)
 436 DEFINE_PARSER(unsigned, unsigned, safe_atou)
 437 DEFINE_PARSER(double, double, safe_atod)
 438 DEFINE_PARSER(nsec, nsec_t, parse_nsec)
 439 DEFINE_PARSER(sec, usec_t, parse_sec)
 440
 441
 442 int config_parse_bytes_size(const char* unit,
 443                             const char *filename,
 444                             unsigned line,
 445                             const char *section,
 446                             unsigned section_line,
 447                             const char *lvalue,
 448                             int ltype,
 449                             const char *rvalue,
 450                             void *data,
 451                             void *userdata) {
 452
 453         size_t *sz = data;
 454         off_t o;
 455         int r;
 456
 457         assert(filename);
 458         assert(lvalue);
 459         assert(rvalue);
 460         assert(data);
 461
 462         r = parse_bytes(rvalue, &o);
 463         if (r < 0 || (off_t) (size_t) o != o) {
 464                 log_syntax(unit, LOG_ERR, filename, line, -r,
 465                            "Failed to parse byte value, ignoring: %s", rvalue);
 466                 return 0;
 467         }
 468
 469         *sz = (size_t) o;
 470         return 0;
 471 }
 472
 473
 474 int config_parse_bytes_off(const char* unit,
 475                            const char *filename,
 476                            unsigned line,
 477                            const char *section,
 478                            unsigned section_line,
 479                            const char *lvalue,
 480                            int ltype,
 481                            const char *rvalue,
 482                            void *data,
 483                            void *userdata) {
 484
 485         off_t *bytes = data;
 486         int r;
 487
 488         assert(filename);
 489         assert(lvalue);
 490         assert(rvalue);
 491         assert(data);
 492
 493         assert_cc(sizeof(off_t) == sizeof(uint64_t));
 494
 495         r = parse_bytes(rvalue, bytes);
 496         if (r < 0)
 497                 log_syntax(unit, LOG_ERR, filename, line, -r,
 498                            "Failed to parse bytes value, ignoring: %s", rvalue);
 499
 500         return 0;
 501 }
 502
 503 int config_parse_bool(const char* unit,
 504                       const char *filename,
 505                       unsigned line,
 506                       const char *section,
 507                       unsigned section_line,
 508                       const char *lvalue,
 509                       int ltype,
 510                       const char *rvalue,
 511                       void *data,
 512                       void *userdata) {
 513
 514         int k;
 515         bool *b = data;
 516
 517         assert(filename);
 518         assert(lvalue);
 519         assert(rvalue);
 520         assert(data);
 521
 522         k = parse_boolean(rvalue);
 523         if (k < 0) {
 524                 log_syntax(unit, LOG_ERR, filename, line, -k,
 525                            "Failed to parse boolean value, ignoring: %s", rvalue);
 526                 return 0;
 527         }
 528
 529         *b = !!k;
 530         return 0;
 531 }
 532
 533 int config_parse_show_status(const char* unit,
 534                              const char *filename,
 535                              unsigned line,
 536                              const char *section,
 537                              unsigned section_line,
 538                              const char *lvalue,
 539                              int ltype,
 540                              const char *rvalue,
 541                              void *data,
 542                              void *userdata) {
 543
 544         int k;
 545         ShowStatus *b = data;
 546
 547         assert(filename);
 548         assert(lvalue);
 549         assert(rvalue);
 550         assert(data);
 551
 552         k = parse_show_status(rvalue, b);
 553         if (k < 0) {
 554                 log_syntax(unit, LOG_ERR, filename, line, -k,
 555                            "Failed to parse show status setting, ignoring: %s", rvalue);
 556                 return 0;
 557         }
 558
 559         return 0;
 560 }
 561
 562 int config_parse_string(const char *unit,
 563                         const char *filename,
 564                         unsigned line,
 565                         const char *section,
 566                         unsigned section_line,
 567                         const char *lvalue,
 568                         int ltype,
 569                         const char *rvalue,
 570                         void *data,
 571                         void *userdata) {
 572
 573         char **s = data;
 574         char *n;
 575
 576         assert(filename);
 577         assert(lvalue);
 578         assert(rvalue);
 579         assert(data);
 580
 581         n = strdup(rvalue);
 582         if (!n)
 583                 return log_oom();
 584
 585         if (!utf8_is_valid(n)) {
 586                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 587                            "String is not UTF-8 clean, ignoring assignment: %s", rvalue);
 588                 free(n);
 589                 return 0;
 590         }
 591
 592         free(*s);
 593         if (*n)
 594                 *s = n;
 595         else {
 596                 free(n);
 597                 *s = NULL;
 598         }
 599
 600         return 0;
 601 }
 602
 603 int config_parse_path(const char *unit,
 604                       const char *filename,
 605                       unsigned line,
 606                       const char *section,
 607                       unsigned section_line,
 608                       const char *lvalue,
 609                       int ltype,
 610                       const char *rvalue,
 611                       void *data,
 612                       void *userdata) {
 613
 614         char **s = data;
 615         char *n;
 616         int offset;
 617
 618         assert(filename);
 619         assert(lvalue);
 620         assert(rvalue);
 621         assert(data);
 622
 623         if (!utf8_is_valid(rvalue)) {
 624                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 625                            "Path is not UTF-8 clean, ignoring assignment: %s", rvalue);
 626                 return 0;
 627         }
 628
 629         offset = rvalue[0] == '-' && (streq(lvalue, "InaccessibleDirectories") ||
 630                                       streq(lvalue, "ReadOnlyDirectories"));
 631         if (!path_is_absolute(rvalue + offset)) {
 632                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 633                            "Not an absolute path, ignoring: %s", rvalue);
 634                 return 0;
 635         }
 636
 637         n = strdup(rvalue);
 638         if (!n)
 639                 return log_oom();
 640
 641         path_kill_slashes(n);
 642
 643         free(*s);
 644         *s = n;
 645
 646         return 0;
 647 }
 648
 649 int config_parse_strv(const char *unit,
 650                       const char *filename,
 651                       unsigned line,
 652                       const char *section,
 653                       unsigned section_line,
 654                       const char *lvalue,
 655                       int ltype,
 656                       const char *rvalue,
 657                       void *data,
 658                       void *userdata) {
 659
 660         char *** sv = data, *w, *state;
 661         size_t l;
 662         int r;
 663
 664         assert(filename);
 665         assert(lvalue);
 666         assert(rvalue);
 667         assert(data);
 668
 669         if (isempty(rvalue)) {
 670                 char **empty;
 671
 672                 /* Empty assignment resets the list. As a special rule
 673                  * we actually fill in a real empty array here rather
 674                  * than NULL, since some code wants to know if
 675                  * something was set at all... */
 676                 empty = strv_new(NULL, NULL);
 677                 if (!empty)
 678                         return log_oom();
 679
 680                 strv_free(*sv);
 681                 *sv = empty;
 682                 return 0;
 683         }
 684
 685         FOREACH_WORD_QUOTED(w, l, rvalue, state) {
 686                 _cleanup_free_ char *n;
 687
 688                 n = cunescape_length(w, l);
 689                 if (!n)
 690                         return log_oom();
 691
 692                 if (!utf8_is_valid(n)) {
 693                         log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 694                                    "String is not UTF-8 clean, ignoring: %s", rvalue);
 695                         continue;
 696                 }
 697
 698                 r = strv_extend(sv, n);
 699                 if (r < 0)
 700                         return log_oom();
 701         }
 702
 703         return 0;
 704 }
 705
 706 int config_parse_path_strv(const char *unit,
 707                            const char *filename,
 708                            unsigned line,
 709                            const char *section,
 710                            unsigned section_line,
 711                            const char *lvalue,
 712                            int ltype,
 713                            const char *rvalue,
 714                            void *data,
 715                            void *userdata) {
 716
 717         char*** sv = data, *w, *state;
 718         size_t l;
 719         int r;
 720
 721         assert(filename);
 722         assert(lvalue);
 723         assert(rvalue);
 724         assert(data);
 725
 726         if (isempty(rvalue)) {
 727                 /* Empty assignment resets the list */
 728                 strv_free(*sv);
 729                 *sv = NULL;
 730                 return 0;
 731         }
 732
 733         FOREACH_WORD_QUOTED(w, l, rvalue, state) {
 734                 _cleanup_free_ char *n;
 735                 int offset;
 736
 737                 n = strndup(w, l);
 738                 if (!n)
 739                         return log_oom();
 740
 741                 if (!utf8_is_valid(n)) {
 742                         log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 743                                    "Path is not UTF-8 clean, ignoring assignment: %s", rvalue);
 744                         continue;
 745                 }
 746
 747                 offset = n[0] == '-' && (streq(lvalue, "InaccessibleDirectories") ||
 748                                          streq(lvalue, "ReadOnlyDirectories"));
 749                 if (!path_is_absolute(n + offset)) {
 750                         log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 751                                    "Not an absolute path, ignoring: %s", rvalue);
 752                         continue;
 753                 }
 754
 755                 path_kill_slashes(n);
 756                 r = strv_extend(sv, n);
 757                 if (r < 0)
 758                         return log_oom();
 759         }
 760
 761         return 0;
 762 }
 763
 764 int config_parse_mode(const char *unit,
 765                       const char *filename,
 766                       unsigned line,
 767                       const char *section,
 768                       unsigned section_line,
 769                       const char *lvalue,
 770                       int ltype,
 771                       const char *rvalue,
 772                       void *data,
 773                       void *userdata) {
 774
 775         mode_t *m = data;
 776         long l;
 777         char *x = NULL;
 778
 779         assert(filename);
 780         assert(lvalue);
 781         assert(rvalue);
 782         assert(data);
 783
 784         errno = 0;
 785         l = strtol(rvalue, &x, 8);
 786         if (!x || x == rvalue || *x || errno) {
 787                 log_syntax(unit, LOG_ERR, filename, line, errno,
 788                            "Failed to parse mode value, ignoring: %s", rvalue);
 789                 return 0;
 790         }
 791
 792         if (l < 0000 || l > 07777) {
 793                 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
 794                            "Mode value out of range, ignoring: %s", rvalue);
 795                 return 0;
 796         }
 797
 798         *m = (mode_t) l;
 799         return 0;
 800 }
 801
 802 int config_parse_facility(const char *unit,
 803                           const char *filename,
 804                           unsigned line,
 805                           const char *section,
 806                           unsigned section_line,
 807                           const char *lvalue,
 808                           int ltype,
 809                           const char *rvalue,
 810                           void *data,
 811                           void *userdata) {
 812
 813
 814         int *o = data, x;
 815
 816         assert(filename);
 817         assert(lvalue);
 818         assert(rvalue);
 819         assert(data);
 820
 821         x = log_facility_unshifted_from_string(rvalue);
 822         if (x < 0) {
 823                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 824                            "Failed to parse log facility, ignoring: %s", rvalue);
 825                 return 0;
 826         }
 827
 828         *o = (x << 3) | LOG_PRI(*o);
 829
 830         return 0;
 831 }
 832
 833 int config_parse_level(const char *unit,
 834                        const char *filename,
 835                        unsigned line,
 836                        const char *section,
 837                        unsigned section_line,
 838                        const char *lvalue,
 839                        int ltype,
 840                        const char *rvalue,
 841                        void *data,
 842                        void *userdata) {
 843
 844
 845         int *o = data, x;
 846
 847         assert(filename);
 848         assert(lvalue);
 849         assert(rvalue);
 850         assert(data);
 851
 852         x = log_level_from_string(rvalue);
 853         if (x < 0) {
 854                 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
 855                            "Failed to parse log level, ignoring: %s", rvalue);
 856                 return 0;
 857         }
 858
 859         *o = (*o & LOG_FACMASK) | x;
 860         return 0;
 861 }
 862
 863 int config_parse_set_status(const char *unit,
 864                             const char *filename,
 865                             unsigned line,
 866                             const char *section,
 867                             unsigned section_line,
 868                             const char *lvalue,
 869                             int ltype,
 870                             const char *rvalue,
 871                             void *data,
 872                             void *userdata) {
 873
 874         char *w;
 875         size_t l;
 876         char *state;
 877         int r;
 878         ExitStatusSet *status_set = data;
 879
 880         assert(filename);
 881         assert(lvalue);
 882         assert(rvalue);
 883         assert(data);
 884
 885         if (isempty(rvalue)) {
 886                 /* Empty assignment resets the list */
 887
 888                 set_free(status_set->signal);
 889                 set_free(status_set->code);
 890
 891                 status_set->signal = status_set->code = NULL;
 892                 return 0;
 893         }
 894
 895         FOREACH_WORD(w, l, rvalue, state) {
 896                 int val;
 897                 char *temp;
 898
 899                 temp = strndup(w, l);
 900                 if (!temp)
 901                         return log_oom();
 902
 903                 r = safe_atoi(temp, &val);
 904                 if (r < 0) {
 905                         val = signal_from_string_try_harder(temp);
 906                         free(temp);
 907
 908                         if (val > 0) {
 909                                 r = set_ensure_allocated(&status_set->signal, trivial_hash_func, trivial_compare_func);
 910                                 if (r < 0)
 911                                         return log_oom();
 912
 913                                 r = set_put(status_set->signal, INT_TO_PTR(val));
 914                                 if (r < 0) {
 915                                         log_syntax(unit, LOG_ERR, filename, line, -r,
 916                                                    "Unable to store: %s", w);
 917                                         return r;
 918                                 }
 919                         } else {
 920                                 log_syntax(unit, LOG_ERR, filename, line, -val,
 921                                            "Failed to parse value, ignoring: %s", w);
 922                                 return 0;
 923                         }
 924                 } else {
 925                         free(temp);
 926
 927                         if (val < 0 || val > 255)
 928                                 log_syntax(unit, LOG_ERR, filename, line, ERANGE,
 929                                            "Value %d is outside range 0-255, ignoring", val);
 930                         else {
 931                                 r = set_ensure_allocated(&status_set->code, trivial_hash_func, trivial_compare_func);
 932                                 if (r < 0)
 933                                         return log_oom();
 934
 935                                 r = set_put(status_set->code, INT_TO_PTR(val));
 936                                 if (r < 0) {
 937                                         log_syntax(unit, LOG_ERR, filename, line, -r,
 938                                                    "Unable to store: %s", w);
 939                                         return r;
 940                                 }
 941                         }
 942                 }
 943         }
 944
 945         return 0;
 946 }