src/network/networkd-dhcp-common.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "in-addr-util.h"
   4 #include "networkd-dhcp-common.h"
   5 #include "networkd-network.h"
   6 #include "parse-util.h"
   7 #include "string-table.h"
   8 #include "strv.h"
   9
  10 int config_parse_dhcp(
  11                 const char* unit,
  12                 const char *filename,
  13                 unsigned line,
  14                 const char *section,
  15                 unsigned section_line,
  16                 const char *lvalue,
  17                 int ltype,
  18                 const char *rvalue,
  19                 void *data,
  20                 void *userdata) {
  21
  22         AddressFamily *dhcp = data, s;
  23
  24         assert(filename);
  25         assert(lvalue);
  26         assert(rvalue);
  27         assert(data);
  28
  29         /* Note that this is mostly like
  30          * config_parse_address_family(), except that it
  31          * understands some old names for the enum values */
  32
  33         s = address_family_from_string(rvalue);
  34         if (s < 0) {
  35
  36                 /* Previously, we had a slightly different enum here,
  37                  * support its values for compatibility. */
  38
  39                 if (streq(rvalue, "none"))
  40                         s = ADDRESS_FAMILY_NO;
  41                 else if (streq(rvalue, "v4"))
  42                         s = ADDRESS_FAMILY_IPV4;
  43                 else if (streq(rvalue, "v6"))
  44                         s = ADDRESS_FAMILY_IPV6;
  45                 else if (streq(rvalue, "both"))
  46                         s = ADDRESS_FAMILY_YES;
  47                 else {
  48                         log_syntax(unit, LOG_ERR, filename, line, 0,
  49                                    "Failed to parse DHCP option, ignoring: %s", rvalue);
  50                         return 0;
  51                 }
  52
  53                 log_syntax(unit, LOG_WARNING, filename, line, 0,
  54                            "DHCP=%s is deprecated, please use DHCP=%s instead.",
  55                            rvalue, address_family_to_string(s));
  56         }
  57
  58         *dhcp = s;
  59         return 0;
  60 }
  61
  62 int config_parse_dhcp_use_dns(
  63                 const char* unit,
  64                 const char *filename,
  65                 unsigned line,
  66                 const char *section,
  67                 unsigned section_line,
  68                 const char *lvalue,
  69                 int ltype,
  70                 const char *rvalue,
  71                 void *data,
  72                 void *userdata) {
  73
  74         Network *network = data;
  75         int r;
  76
  77         assert(filename);
  78         assert(lvalue);
  79         assert(rvalue);
  80         assert(data);
  81
  82         r = parse_boolean(rvalue);
  83         if (r < 0) {
  84                 log_syntax(unit, LOG_ERR, filename, line, r,
  85                            "Failed to parse UseDNS=%s, ignoring assignment: %m", rvalue);
  86                 return 0;
  87         }
  88
  89         network->dhcp_use_dns = r;
  90         network->dhcp6_use_dns = r;
  91
  92         return 0;
  93 }
  94
  95 int config_parse_dhcp_use_sip(
  96                 const char* unit,
  97                 const char *filename,
  98                 unsigned line,
  99                 const char *section,
 100                 unsigned section_line,
 101                 const char *lvalue,
 102                 int ltype,
 103                 const char *rvalue,
 104                 void *data,
 105                 void *userdata) {
 106
 107         Network *network = data;
 108         int r;
 109
 110         assert(filename);
 111         assert(lvalue);
 112         assert(rvalue);
 113         assert(data);
 114
 115         r = parse_boolean(rvalue);
 116         if (r < 0) {
 117                 log_syntax(unit, LOG_ERR, filename, line, r,
 118                            "Failed to parse UseSIP=%s, ignoring assignment: %m", rvalue);
 119                 return 0;
 120         }
 121
 122         network->dhcp_use_sip = r;
 123
 124         return 0;
 125 }
 126
 127 int config_parse_dhcp_use_ntp(
 128                 const char* unit,
 129                 const char *filename,
 130                 unsigned line,
 131                 const char *section,
 132                 unsigned section_line,
 133                 const char *lvalue,
 134                 int ltype,
 135                 const char *rvalue,
 136                 void *data,
 137                 void *userdata) {
 138
 139         Network *network = data;
 140         int r;
 141
 142         assert(filename);
 143         assert(lvalue);
 144         assert(rvalue);
 145         assert(data);
 146
 147         r = parse_boolean(rvalue);
 148         if (r < 0) {
 149                 log_syntax(unit, LOG_ERR, filename, line, r,
 150                            "Failed to parse UseNTP=%s, ignoring assignment: %m", rvalue);
 151                 return 0;
 152         }
 153
 154         network->dhcp_use_ntp = r;
 155         network->dhcp6_use_ntp = r;
 156
 157         return 0;
 158 }
 159
 160 int config_parse_section_route_table(
 161                 const char *unit,
 162                 const char *filename,
 163                 unsigned line,
 164                 const char *section,
 165                 unsigned section_line,
 166                 const char *lvalue,
 167                 int ltype,
 168                 const char *rvalue,
 169                 void *data,
 170                 void *userdata) {
 171
 172         Network *network = data;
 173         uint32_t rt;
 174         int r;
 175
 176         assert(filename);
 177         assert(lvalue);
 178         assert(rvalue);
 179         assert(data);
 180
 181         r = safe_atou32(rvalue, &rt);
 182         if (r < 0) {
 183                 log_syntax(unit, LOG_ERR, filename, line, r,
 184                            "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue);
 185                 return 0;
 186         }
 187
 188         if (STRPTR_IN_SET(section, "DHCP", "DHCPv4")) {
 189                 network->dhcp_route_table = rt;
 190                 network->dhcp_route_table_set = true;
 191         } else { /* section is IPv6AcceptRA */
 192                 network->ipv6_accept_ra_route_table = rt;
 193                 network->ipv6_accept_ra_route_table_set = true;
 194         }
 195
 196         return 0;
 197 }
 198
 199 int config_parse_iaid(const char *unit,
 200                       const char *filename,
 201                       unsigned line,
 202                       const char *section,
 203                       unsigned section_line,
 204                       const char *lvalue,
 205                       int ltype,
 206                       const char *rvalue,
 207                       void *data,
 208                       void *userdata) {
 209         Network *network = data;
 210         uint32_t iaid;
 211         int r;
 212
 213         assert(filename);
 214         assert(lvalue);
 215         assert(rvalue);
 216         assert(network);
 217
 218         r = safe_atou32(rvalue, &iaid);
 219         if (r < 0) {
 220                 log_syntax(unit, LOG_ERR, filename, line, r,
 221                            "Unable to read IAID, ignoring assignment: %s", rvalue);
 222                 return 0;
 223         }
 224
 225         network->iaid = iaid;
 226         network->iaid_set = true;
 227
 228         return 0;
 229 }
 230
 231 int config_parse_dhcp6_pd_hint(
 232                 const char* unit,
 233                 const char *filename,
 234                 unsigned line,
 235                 const char *section,
 236                 unsigned section_line,
 237                 const char *lvalue,
 238                 int ltype,
 239                 const char *rvalue,
 240                 void *data,
 241                 void *userdata) {
 242
 243         Network *network = data;
 244         int r;
 245
 246         assert(filename);
 247         assert(lvalue);
 248         assert(rvalue);
 249         assert(data);
 250
 251         r = in_addr_prefix_from_string(rvalue, AF_INET6, (union in_addr_union *) &network->dhcp6_pd_address, &network->dhcp6_pd_length);
 252         if (r < 0) {
 253                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse PrefixDelegationHint=%s, ignoring assignment", rvalue);
 254                 return 0;
 255         }
 256
 257         if (network->dhcp6_pd_length < 1 || network->dhcp6_pd_length > 128) {
 258                 log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid prefix length='%d', ignoring assignment", network->dhcp6_pd_length);
 259                 network->dhcp6_pd_length = 0;
 260                 return 0;
 261         }
 262
 263         return 0;
 264 }
 265
 266 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_use_domains, dhcp_use_domains, DHCPUseDomains,
 267                          "Failed to parse DHCP use domains setting");
 268
 269 static const char* const dhcp_use_domains_table[_DHCP_USE_DOMAINS_MAX] = {
 270         [DHCP_USE_DOMAINS_NO] = "no",
 271         [DHCP_USE_DOMAINS_ROUTE] = "route",
 272         [DHCP_USE_DOMAINS_YES] = "yes",
 273 };
 274
 275 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(dhcp_use_domains, DHCPUseDomains, DHCP_USE_DOMAINS_YES);
 276
 277 static const char * const dhcp_option_data_type_table[_DHCP_OPTION_DATA_MAX] = {
 278         [DHCP_OPTION_DATA_UINT8]       = "uint8",
 279         [DHCP_OPTION_DATA_UINT16]      = "uint16",
 280         [DHCP_OPTION_DATA_UINT32]      = "uint32",
 281         [DHCP_OPTION_DATA_STRING]      = "string",
 282         [DHCP_OPTION_DATA_IPV4ADDRESS] = "ipv4address",
 283 };
 284
 285 DEFINE_STRING_TABLE_LOOKUP(dhcp_option_data_type, DHCPOptionDataType);