src/shared/conf-parser.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2010 Lennart Poettering
   8 ***/
   9
  10 #include <errno.h>
  11 #include <stdbool.h>
  12 #include <stddef.h>
  13 #include <stdio.h>
  14 #include <syslog.h>
  15
  16 #include "alloc-util.h"
  17 #include "log.h"
  18 #include "macro.h"
  19
  20 /* An abstract parser for simple, line based, shallow configuration files consisting of variable assignments only. */
  21
  22 typedef enum ConfigParseFlags {
  23         CONFIG_PARSE_RELAXED       = 1U << 0,
  24         CONFIG_PARSE_ALLOW_INCLUDE = 1U << 1,
  25         CONFIG_PARSE_WARN          = 1U << 2,
  26         CONFIG_PARSE_REFUSE_BOM    = 1U << 3,
  27 } ConfigParseFlags;
  28
  29 /* Prototype for a parser for a specific configuration setting */
  30 typedef int (*ConfigParserCallback)(const char *unit,
  31                                     const char *filename,
  32                                     unsigned line,
  33                                     const char *section,
  34                                     unsigned section_line,
  35                                     const char *lvalue,
  36                                     int ltype,
  37                                     const char *rvalue,
  38                                     void *data,
  39                                     void *userdata);
  40
  41 /* Wraps information for parsing a specific configuration variable, to
  42  * be stored in a simple array */
  43 typedef struct ConfigTableItem {
  44         const char *section;            /* Section */
  45         const char *lvalue;             /* Name of the variable */
  46         ConfigParserCallback parse;     /* Function that is called to parse the variable's value */
  47         int ltype;                      /* Distinguish different variables passed to the same callback */
  48         void *data;                     /* Where to store the variable's data */
  49 } ConfigTableItem;
  50
  51 /* Wraps information for parsing a specific configuration variable, to
  52  * be stored in a gperf perfect hashtable */
  53 typedef struct ConfigPerfItem {
  54         const char *section_and_lvalue; /* Section + "." + name of the variable */
  55         ConfigParserCallback parse;     /* Function that is called to parse the variable's value */
  56         int ltype;                      /* Distinguish different variables passed to the same callback */
  57         size_t offset;                  /* Offset where to store data, from the beginning of userdata */
  58 } ConfigPerfItem;
  59
  60 /* Prototype for a low-level gperf lookup function */
  61 typedef const ConfigPerfItem* (*ConfigPerfItemLookup)(const char *section_and_lvalue, unsigned length);
  62
  63 /* Prototype for a generic high-level lookup function */
  64 typedef int (*ConfigItemLookup)(
  65                 const void *table,
  66                 const char *section,
  67                 const char *lvalue,
  68                 ConfigParserCallback *func,
  69                 int *ltype,
  70                 void **data,
  71                 void *userdata);
  72
  73 /* Linear table search implementation of ConfigItemLookup, based on
  74  * ConfigTableItem arrays */
  75 int config_item_table_lookup(const void *table, const char *section, const char *lvalue, ConfigParserCallback *func, int *ltype, void **data, void *userdata);
  76
  77 /* gperf implementation of ConfigItemLookup, based on gperf
  78  * ConfigPerfItem tables */
  79 int config_item_perf_lookup(const void *table, const char *section, const char *lvalue, ConfigParserCallback *func, int *ltype, void **data, void *userdata);
  80
  81 int config_parse(
  82                 const char *unit,
  83                 const char *filename,
  84                 FILE *f,
  85                 const char *sections,  /* nulstr */
  86                 ConfigItemLookup lookup,
  87                 const void *table,
  88                 ConfigParseFlags flags,
  89                 void *userdata);
  90
  91 int config_parse_many_nulstr(
  92                 const char *conf_file,      /* possibly NULL */
  93                 const char *conf_file_dirs, /* nulstr */
  94                 const char *sections,       /* nulstr */
  95                 ConfigItemLookup lookup,
  96                 const void *table,
  97                 ConfigParseFlags flags,
  98                 void *userdata);
  99
 100 #if 0 /// UNNEEDED by elogind
 101 int config_parse_many(
 102                 const char *conf_file,      /* possibly NULL */
 103                 const char* const* conf_file_dirs,
 104                 const char *dropin_dirname,
 105                 const char *sections,       /* nulstr */
 106                 ConfigItemLookup lookup,
 107                 const void *table,
 108                 ConfigParseFlags flags,
 109                 void *userdata);
 110 #endif // 0
 111
 112 /* Generic parsers */
 113 #if 0 /// UNNEEDED by elogind
 114 #endif // 0
 115 #if 0 /// UNNEEDED by elogind
 116 #endif // 0
 117 #if 0 /// UNNEEDED by elogind
 118 #endif // 0
 119 #if 0 /// UNNEEDED by elogind
 120 #endif // 0
 121 #if 0 /// UNNEEDED by elogind
 122 #endif // 0
 123 #if 0 /// UNNEEDED by elogind
 124 #endif // 0
 125 #define GENERIC_PARSER_ARGS \
 126                 const char *unit,                                       \
 127                 const char *filename,                                   \
 128                 unsigned line,                                          \
 129                 const char *section,                                    \
 130                 unsigned section_line,                                  \
 131                 const char *lvalue,                                     \
 132                 int ltype,                                              \
 133                 const char *rvalue,                                     \
 134                 void *data,                                             \
 135                 void *userdata
 136 int config_parse_int(GENERIC_PARSER_ARGS);
 137 int config_parse_unsigned(GENERIC_PARSER_ARGS);
 138 int config_parse_long(GENERIC_PARSER_ARGS);
 139 int config_parse_uint8(GENERIC_PARSER_ARGS);
 140 int config_parse_uint16(GENERIC_PARSER_ARGS);
 141 int config_parse_uint32(GENERIC_PARSER_ARGS);
 142 int config_parse_uint64(GENERIC_PARSER_ARGS);
 143 int config_parse_double(GENERIC_PARSER_ARGS);
 144 int config_parse_iec_size(GENERIC_PARSER_ARGS);
 145 int config_parse_si_size(GENERIC_PARSER_ARGS);
 146 int config_parse_iec_uint64(GENERIC_PARSER_ARGS);
 147 int config_parse_bool(GENERIC_PARSER_ARGS);
 148 int config_parse_tristate(GENERIC_PARSER_ARGS);
 149 int config_parse_string(GENERIC_PARSER_ARGS);
 150 int config_parse_path(GENERIC_PARSER_ARGS);
 151 int config_parse_strv(GENERIC_PARSER_ARGS);
 152 int config_parse_sec(GENERIC_PARSER_ARGS);
 153 int config_parse_nsec(GENERIC_PARSER_ARGS);
 154 int config_parse_mode(GENERIC_PARSER_ARGS);
 155 int config_parse_warn_compat(GENERIC_PARSER_ARGS);
 156 int config_parse_log_facility(GENERIC_PARSER_ARGS);
 157 int config_parse_log_level(GENERIC_PARSER_ARGS);
 158 int config_parse_signal(GENERIC_PARSER_ARGS);
 159 int config_parse_personality(GENERIC_PARSER_ARGS);
 160 int config_parse_ifname(GENERIC_PARSER_ARGS);
 161 int config_parse_ip_port(GENERIC_PARSER_ARGS);
 162 #if 0 /// UNNEEDED by elogind
 163 int config_parse_join_controllers(GENERIC_PARSER_ARGS);
 164 #endif // 0
 165
 166 typedef enum Disabled {
 167         DISABLED_CONFIGURATION,
 168         DISABLED_LEGACY,
 169         DISABLED_EXPERIMENTAL,
 170 } Disabled;
 171
 172 #define DEFINE_CONFIG_PARSE_ENUM(function,name,type,msg)                \
 173         int function(GENERIC_PARSER_ARGS) {                             \
 174                 type *i = data, x;                                      \
 175                                                                         \
 176                 assert(filename);                                       \
 177                 assert(lvalue);                                         \
 178                 assert(rvalue);                                         \
 179                 assert(data);                                           \
 180                                                                         \
 181                 if ((x = name##_from_string(rvalue)) < 0) {             \
 182                         log_syntax(unit, LOG_ERR, filename, line, -x,   \
 183                                    msg ", ignoring: %s", rvalue);       \
 184                         return 0;                                       \
 185                 }                                                       \
 186                                                                         \
 187                 *i = x;                                                 \
 188                 return 0;                                               \
 189         }
 190
 191 #define DEFINE_CONFIG_PARSE_ENUMV(function,name,type,invalid,msg)              \
 192         int function(GENERIC_PARSER_ARGS) {                                    \
 193                 type **enums = data, x, *ys;                                   \
 194                 _cleanup_free_ type *xs = NULL;                                \
 195                 const char *word, *state;                                      \
 196                 size_t l, i = 0;                                               \
 197                                                                                \
 198                 assert(filename);                                              \
 199                 assert(lvalue);                                                \
 200                 assert(rvalue);                                                \
 201                 assert(data);                                                  \
 202                                                                                \
 203                 xs = new0(type, 1);                                            \
 204                 if (!xs)                                                       \
 205                         return -ENOMEM;                                        \
 206                                                                                \
 207                 *xs = invalid;                                                 \
 208                                                                                \
 209                 FOREACH_WORD(word, l, rvalue, state) {                         \
 210                         _cleanup_free_ char *en = NULL;                        \
 211                         type *new_xs;                                          \
 212                                                                                \
 213                         en = strndup(word, l);                                 \
 214                         if (!en)                                               \
 215                                 return -ENOMEM;                                \
 216                                                                                \
 217                         if ((x = name##_from_string(en)) < 0) {                \
 218                                 log_syntax(unit, LOG_ERR, filename, line,      \
 219                                        -x, msg ", ignoring: %s", en);          \
 220                                 continue;                                      \
 221                         }                                                      \
 222                                                                                \
 223                         for (ys = xs; x != invalid && *ys != invalid; ys++) {  \
 224                                 if (*ys == x) {                                \
 225                                         log_syntax(unit, LOG_ERR, filename,    \
 226                                               line, -x,                        \
 227                                               "Duplicate entry, ignoring: %s", \
 228                                               en);                             \
 229                                         x = invalid;                           \
 230                                 }                                              \
 231                         }                                                      \
 232                                                                                \
 233                         if (x == invalid)                                      \
 234                                 continue;                                      \
 235                                                                                \
 236                         *(xs + i) = x;                                         \
 237                         new_xs = realloc(xs, (++i + 1) * sizeof(type));        \
 238                         if (new_xs)                                            \
 239                                 xs = new_xs;                                   \
 240                         else                                                   \
 241                                 return -ENOMEM;                                \
 242                                                                                \
 243                         *(xs + i) = invalid;                                   \
 244                 }                                                              \
 245                                                                                \
 246                 free(*enums);                                                  \
 247                 *enums = xs;                                                   \
 248                 xs = NULL;                                                     \
 249                                                                                \
 250                 return 0;                                                      \
 251         }