src/network/networkd-dhcp-server.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <netinet/in.h>
   4 #include <linux/if_arp.h>
   5 #include <linux/if.h>
   6
   7 #include "sd-dhcp-server.h"
   8
   9 #include "fd-util.h"
  10 #include "fileio.h"
  11 #include "networkd-address.h"
  12 #include "networkd-dhcp-server-bus.h"
  13 #include "networkd-dhcp-server-static-lease.h"
  14 #include "networkd-dhcp-server.h"
  15 #include "networkd-link.h"
  16 #include "networkd-manager.h"
  17 #include "networkd-network.h"
  18 #include "networkd-queue.h"
  19 #include "networkd-route-util.h"
  20 #include "parse-util.h"
  21 #include "socket-netlink.h"
  22 #include "string-table.h"
  23 #include "string-util.h"
  24 #include "strv.h"
  25
  26 static bool link_dhcp4_server_enabled(Link *link) {
  27         assert(link);
  28
  29         if (link->flags & IFF_LOOPBACK)
  30                 return false;
  31
  32         if (!link->network)
  33                 return false;
  34
  35         if (link->iftype == ARPHRD_CAN)
  36                 return false;
  37
  38         return link->network->dhcp_server;
  39 }
  40
  41 void network_adjust_dhcp_server(Network *network) {
  42         assert(network);
  43
  44         if (!network->dhcp_server)
  45                 return;
  46
  47         if (network->bond) {
  48                 log_warning("%s: DHCPServer= is enabled for bond slave. Disabling DHCP server.",
  49                             network->filename);
  50                 network->dhcp_server = false;
  51                 return;
  52         }
  53
  54         if (!in4_addr_is_set(&network->dhcp_server_address)) {
  55                 Address *address;
  56                 bool have = false;
  57
  58                 ORDERED_HASHMAP_FOREACH(address, network->addresses_by_section) {
  59                         if (section_is_invalid(address->section))
  60                                 continue;
  61
  62                         if (address->family != AF_INET)
  63                                 continue;
  64
  65                         if (in4_addr_is_localhost(&address->in_addr.in))
  66                                 continue;
  67
  68                         if (in4_addr_is_link_local(&address->in_addr.in))
  69                                 continue;
  70
  71                         if (in4_addr_is_set(&address->in_addr_peer.in))
  72                                 continue;
  73
  74                         have = true;
  75                         break;
  76                 }
  77                 if (!have) {
  78                         log_warning("%s: DHCPServer= is enabled, but no static address configured. "
  79                                     "Disabling DHCP server.",
  80                                     network->filename);
  81                         network->dhcp_server = false;
  82                         return;
  83                 }
  84         }
  85 }
  86
  87 int link_request_dhcp_server_address(Link *link) {
  88         _cleanup_(address_freep) Address *address = NULL;
  89         Address *existing;
  90         int r;
  91
  92         assert(link);
  93         assert(link->network);
  94
  95         if (!link_dhcp4_server_enabled(link))
  96                 return 0;
  97
  98         if (!in4_addr_is_set(&link->network->dhcp_server_address))
  99                 return 0;
 100
 101         r = address_new(&address);
 102         if (r < 0)
 103                 return r;
 104
 105         address->source = NETWORK_CONFIG_SOURCE_STATIC;
 106         address->family = AF_INET;
 107         address->in_addr.in = link->network->dhcp_server_address;
 108         address->prefixlen = link->network->dhcp_server_address_prefixlen;
 109         address_set_broadcast(address, link);
 110
 111         if (address_get(link, address, &existing) >= 0 &&
 112             address_exists(existing) &&
 113             existing->source == NETWORK_CONFIG_SOURCE_STATIC)
 114                 /* The same address seems explicitly configured in [Address] or [Network] section.
 115                  * Configure the DHCP server address only when it is not. */
 116                 return 0;
 117
 118         return link_request_static_address(link, TAKE_PTR(address), true);
 119 }
 120
 121 static int link_find_dhcp_server_address(Link *link, Address **ret) {
 122         Address *address;
 123
 124         assert(link);
 125         assert(link->network);
 126
 127         /* If ServerAddress= is specified, then use the address. */
 128         if (in4_addr_is_set(&link->network->dhcp_server_address))
 129                 return link_get_ipv4_address(link, &link->network->dhcp_server_address,
 130                                              link->network->dhcp_server_address_prefixlen, ret);
 131
 132         /* If not, then select one from static addresses. */
 133         SET_FOREACH(address, link->addresses) {
 134                 if (address->source != NETWORK_CONFIG_SOURCE_STATIC)
 135                         continue;
 136                 if (!address_exists(address))
 137                         continue;
 138                 if (address->family != AF_INET)
 139                         continue;
 140                 if (in4_addr_is_localhost(&address->in_addr.in))
 141                         continue;
 142                 if (in4_addr_is_link_local(&address->in_addr.in))
 143                         continue;
 144                 if (in4_addr_is_set(&address->in_addr_peer.in))
 145                         continue;
 146
 147                 *ret = address;
 148                 return 0;
 149         }
 150
 151         return -ENOENT;
 152 }
 153
 154 static int dhcp_server_find_uplink(Link *link, Link **ret) {
 155         assert(link);
 156
 157         if (link->network->dhcp_server_uplink_name)
 158                 return link_get_by_name(link->manager, link->network->dhcp_server_uplink_name, ret);
 159
 160         if (link->network->dhcp_server_uplink_index > 0)
 161                 return link_get_by_index(link->manager, link->network->dhcp_server_uplink_index, ret);
 162
 163         if (link->network->dhcp_server_uplink_index == UPLINK_INDEX_AUTO) {
 164                 /* It is not necessary to propagate error in automatic selection. */
 165                 if (manager_find_uplink(link->manager, AF_INET, link, ret) < 0)
 166                         *ret = NULL;
 167                 return 0;
 168         }
 169
 170         *ret = NULL;
 171         return 0;
 172 }
 173
 174 static int link_push_uplink_to_dhcp_server(
 175                 Link *link,
 176                 sd_dhcp_lease_server_type_t what,
 177                 sd_dhcp_server *s) {
 178
 179         _cleanup_free_ struct in_addr *addresses = NULL;
 180         bool use_dhcp_lease_data = true;
 181         size_t n_addresses = 0;
 182
 183         assert(link);
 184
 185         if (!link->network)
 186                 return 0;
 187         assert(link->network);
 188
 189         log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what));
 190
 191         switch (what) {
 192
 193         case SD_DHCP_LEASE_DNS:
 194                 /* For DNS we have a special case. We the data configured explicitly locally along with the
 195                  * data from the DHCP lease. */
 196
 197                 for (unsigned i = 0; i < link->network->n_dns; i++) {
 198                         struct in_addr ia;
 199
 200                         /* Only look for IPv4 addresses */
 201                         if (link->network->dns[i]->family != AF_INET)
 202                                 continue;
 203
 204                         ia = link->network->dns[i]->address.in;
 205
 206                         /* Never propagate obviously borked data */
 207                         if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia))
 208                                 continue;
 209
 210                         if (!GREEDY_REALLOC(addresses, n_addresses + 1))
 211                                 return log_oom();
 212
 213                         addresses[n_addresses++] = ia;
 214                 }
 215
 216                 use_dhcp_lease_data = link->network->dhcp_use_dns;
 217                 break;
 218
 219         case SD_DHCP_LEASE_NTP: {
 220                 /* For NTP things are similar, but for NTP hostnames can be configured too, which we cannot
 221                  * propagate via DHCP. Hence let's only propagate those which are IP addresses. */
 222
 223                 STRV_FOREACH(i, link->network->ntp) {
 224                         union in_addr_union ia;
 225
 226                         if (in_addr_from_string(AF_INET, *i, &ia) < 0)
 227                                 continue;
 228
 229                         /* Never propagate obviously borked data */
 230                         if (in4_addr_is_null(&ia.in) || in4_addr_is_localhost(&ia.in))
 231                                 continue;
 232
 233                         if (!GREEDY_REALLOC(addresses, n_addresses + 1))
 234                                 return log_oom();
 235
 236                         addresses[n_addresses++] = ia.in;
 237                 }
 238
 239                 use_dhcp_lease_data = link->network->dhcp_use_ntp;
 240                 break;
 241         }
 242
 243         case SD_DHCP_LEASE_SIP:
 244
 245                 /* For SIP we don't allow explicit, local configuration, but there's control whether to use the data */
 246                 use_dhcp_lease_data = link->network->dhcp_use_sip;
 247                 break;
 248
 249         case SD_DHCP_LEASE_POP3:
 250         case SD_DHCP_LEASE_SMTP:
 251         case SD_DHCP_LEASE_LPR:
 252                 /* For the other server types we currently do not allow local configuration of server data,
 253                  * since there are typically no local consumers of the data. */
 254                 break;
 255
 256         default:
 257                 assert_not_reached();
 258         }
 259
 260         if (use_dhcp_lease_data && link->dhcp_lease) {
 261                 const struct in_addr *da;
 262
 263                 int n = sd_dhcp_lease_get_servers(link->dhcp_lease, what, &da);
 264                 if (n > 0) {
 265                         if (!GREEDY_REALLOC(addresses, n_addresses + n))
 266                                 return log_oom();
 267
 268                         for (int j = 0; j < n; j++)
 269                                 if (in4_addr_is_non_local(&da[j]))
 270                                         addresses[n_addresses++] = da[j];
 271                 }
 272         }
 273
 274         if (n_addresses <= 0)
 275                 return 0;
 276
 277         return sd_dhcp_server_set_servers(s, what, addresses, n_addresses);
 278 }
 279
 280 static int dhcp4_server_parse_dns_server_string_and_warn(
 281                 const char *string,
 282                 struct in_addr **addresses,
 283                 size_t *n_addresses) {
 284
 285         for (;;) {
 286                 _cleanup_free_ char *word = NULL, *server_name = NULL;
 287                 union in_addr_union address;
 288                 int family, r, ifindex = 0;
 289
 290                 r = extract_first_word(&string, &word, NULL, 0);
 291                 if (r < 0)
 292                         return r;
 293                 if (r == 0)
 294                         break;
 295
 296                 r = in_addr_ifindex_name_from_string_auto(word, &family, &address, &ifindex, &server_name);
 297                 if (r < 0) {
 298                         log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring: %m", word);
 299                         continue;
 300                 }
 301
 302                 /* Only look for IPv4 addresses */
 303                 if (family != AF_INET)
 304                         continue;
 305
 306                 /* Never propagate obviously borked data */
 307                 if (in4_addr_is_null(&address.in) || in4_addr_is_localhost(&address.in))
 308                         continue;
 309
 310                 if (!GREEDY_REALLOC(*addresses, *n_addresses + 1))
 311                         return log_oom();
 312
 313                 (*addresses)[(*n_addresses)++] = address.in;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int dhcp4_server_set_dns_from_resolve_conf(Link *link) {
 320         _cleanup_free_ struct in_addr *addresses = NULL;
 321         _cleanup_fclose_ FILE *f = NULL;
 322         size_t n_addresses = 0;
 323         int n = 0, r;
 324
 325         f = fopen(PRIVATE_UPLINK_RESOLV_CONF, "re");
 326         if (!f) {
 327                 if (errno == ENOENT)
 328                         return 0;
 329
 330                 return log_warning_errno(errno, "Failed to open " PRIVATE_UPLINK_RESOLV_CONF ": %m");
 331         }
 332
 333         for (;;) {
 334                 _cleanup_free_ char *line = NULL;
 335                 const char *a;
 336                 char *l;
 337
 338                 r = read_line(f, LONG_LINE_MAX, &line);
 339                 if (r < 0)
 340                         return log_error_errno(r, "Failed to read " PRIVATE_UPLINK_RESOLV_CONF ": %m");
 341                 if (r == 0)
 342                         break;
 343
 344                 n++;
 345
 346                 l = strstrip(line);
 347                 if (IN_SET(*l, '#', ';', 0))
 348                         continue;
 349
 350                 a = first_word(l, "nameserver");
 351                 if (!a)
 352                         continue;
 353
 354                 r = dhcp4_server_parse_dns_server_string_and_warn(a, &addresses, &n_addresses);
 355                 if (r < 0)
 356                         log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring.", a);
 357         }
 358
 359         if (n_addresses <= 0)
 360                 return 0;
 361
 362         return sd_dhcp_server_set_dns(link->dhcp_server, addresses, n_addresses);
 363 }
 364
 365 static int dhcp4_server_configure(Link *link) {
 366         bool acquired_uplink = false;
 367         sd_dhcp_option *p;
 368         DHCPStaticLease *static_lease;
 369         Link *uplink = NULL;
 370         Address *address;
 371         bool bind_to_interface;
 372         int r;
 373
 374         assert(link);
 375
 376         log_link_debug(link, "Configuring DHCP Server.");
 377
 378         if (link->dhcp_server)
 379                 return -EBUSY;
 380
 381         r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
 382         if (r < 0)
 383                 return r;
 384
 385         r = sd_dhcp_server_attach_event(link->dhcp_server, link->manager->event, 0);
 386         if (r < 0)
 387                 return r;
 388
 389         r = sd_dhcp_server_set_callback(link->dhcp_server, dhcp_server_callback, link);
 390         if (r < 0)
 391                 return log_link_warning_errno(link, r, "Failed to set callback for DHCPv4 server instance: %m");
 392
 393         r = link_find_dhcp_server_address(link, &address);
 394         if (r < 0)
 395                 return log_link_error_errno(link, r, "Failed to find suitable address for DHCPv4 server instance: %m");
 396
 397         /* use the server address' subnet as the pool */
 398         r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen,
 399                                           link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size);
 400         if (r < 0)
 401                 return log_link_error_errno(link, r, "Failed to configure address pool for DHCPv4 server instance: %m");
 402
 403         if (link->network->dhcp_server_max_lease_time_usec > 0) {
 404                 r = sd_dhcp_server_set_max_lease_time(link->dhcp_server,
 405                                                       DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
 406                 if (r < 0)
 407                         return log_link_error_errno(link, r, "Failed to set maximum lease time for DHCPv4 server instance: %m");
 408         }
 409
 410         if (link->network->dhcp_server_default_lease_time_usec > 0) {
 411                 r = sd_dhcp_server_set_default_lease_time(link->dhcp_server,
 412                                                           DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
 413                 if (r < 0)
 414                         return log_link_error_errno(link, r, "Failed to set default lease time for DHCPv4 server instance: %m");
 415         }
 416
 417         r = sd_dhcp_server_set_boot_server_address(link->dhcp_server, &link->network->dhcp_server_boot_server_address);
 418         if (r < 0)
 419                 return log_link_warning_errno(link, r, "Failed to set boot server address for DHCPv4 server instance: %m");
 420
 421         r = sd_dhcp_server_set_boot_server_name(link->dhcp_server, link->network->dhcp_server_boot_server_name);
 422         if (r < 0)
 423                 return log_link_warning_errno(link, r, "Failed to set boot server name for DHCPv4 server instance: %m");
 424
 425         r = sd_dhcp_server_set_boot_filename(link->dhcp_server, link->network->dhcp_server_boot_filename);
 426         if (r < 0)
 427                 return log_link_warning_errno(link, r, "Failed to set boot filename for DHCPv4 server instance: %m");
 428
 429         for (sd_dhcp_lease_server_type_t type = 0; type < _SD_DHCP_LEASE_SERVER_TYPE_MAX; type ++) {
 430
 431                 if (!link->network->dhcp_server_emit[type].emit)
 432                         continue;
 433
 434                 if (link->network->dhcp_server_emit[type].n_addresses > 0)
 435                         /* Explicitly specified servers to emit */
 436                         r = sd_dhcp_server_set_servers(
 437                                         link->dhcp_server,
 438                                         type,
 439                                         link->network->dhcp_server_emit[type].addresses,
 440                                         link->network->dhcp_server_emit[type].n_addresses);
 441                 else {
 442                         /* Emission is requested, but nothing explicitly configured. Let's find a suitable upling */
 443                         if (!acquired_uplink) {
 444                                 (void) dhcp_server_find_uplink(link, &uplink);
 445                                 acquired_uplink = true;
 446                         }
 447
 448                         if (uplink && uplink->network)
 449                                 r = link_push_uplink_to_dhcp_server(uplink, type, link->dhcp_server);
 450                         else if (type == SD_DHCP_LEASE_DNS)
 451                                 r = dhcp4_server_set_dns_from_resolve_conf(link);
 452                         else {
 453                                 log_link_debug(link,
 454                                                "Not emitting %s on link, couldn't find suitable uplink.",
 455                                                dhcp_lease_server_type_to_string(type));
 456                                 continue;
 457                         }
 458                 }
 459
 460                 if (r < 0)
 461                         log_link_warning_errno(link, r,
 462                                                "Failed to set %s for DHCP server, ignoring: %m",
 463                                                dhcp_lease_server_type_to_string(type));
 464         }
 465
 466         if (link->network->dhcp_server_emit_router) {
 467                 r = sd_dhcp_server_set_router(link->dhcp_server, &link->network->dhcp_server_router);
 468                 if (r < 0)
 469                         return log_link_error_errno(link, r, "Failed to set router address for DHCP server: %m");
 470         }
 471
 472         r = sd_dhcp_server_set_relay_target(link->dhcp_server, &link->network->dhcp_server_relay_target);
 473         if (r < 0)
 474                 return log_link_error_errno(link, r, "Failed to set relay target for DHCP server: %m");
 475
 476         bind_to_interface = sd_dhcp_server_is_in_relay_mode(link->dhcp_server) ? false : link->network->dhcp_server_bind_to_interface;
 477         r = sd_dhcp_server_set_bind_to_interface(link->dhcp_server, bind_to_interface);
 478         if (r < 0)
 479                 return log_link_error_errno(link, r, "Failed to set interface binding for DHCP server: %m");
 480
 481         r = sd_dhcp_server_set_relay_agent_information(link->dhcp_server, link->network->dhcp_server_relay_agent_circuit_id, link->network->dhcp_server_relay_agent_remote_id);
 482         if (r < 0)
 483                 return log_link_error_errno(link, r, "Failed to set agent circuit/remote id for DHCP server: %m");
 484
 485         if (link->network->dhcp_server_emit_timezone) {
 486                 _cleanup_free_ char *buffer = NULL;
 487                 const char *tz = NULL;
 488
 489                 if (link->network->dhcp_server_timezone)
 490                         tz = link->network->dhcp_server_timezone;
 491                 else {
 492                         r = get_timezone(&buffer);
 493                         if (r < 0)
 494                                 log_link_warning_errno(link, r, "Failed to determine timezone, not sending timezone: %m");
 495                         else
 496                                 tz = buffer;
 497                 }
 498
 499                 if (tz) {
 500                         r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
 501                         if (r < 0)
 502                                 return log_link_error_errno(link, r, "Failed to set timezone for DHCP server: %m");
 503                 }
 504         }
 505
 506         ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options) {
 507                 r = sd_dhcp_server_add_option(link->dhcp_server, p);
 508                 if (r == -EEXIST)
 509                         continue;
 510                 if (r < 0)
 511                         return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
 512         }
 513
 514         ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options) {
 515                 r = sd_dhcp_server_add_vendor_option(link->dhcp_server, p);
 516                 if (r == -EEXIST)
 517                         continue;
 518                 if (r < 0)
 519                         return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
 520         }
 521
 522         HASHMAP_FOREACH(static_lease, link->network->dhcp_static_leases_by_section) {
 523                 r = sd_dhcp_server_set_static_lease(link->dhcp_server, &static_lease->address, static_lease->client_id, static_lease->client_id_size);
 524                 if (r < 0)
 525                         return log_link_error_errno(link, r, "Failed to set DHCPv4 static lease for DHCP server: %m");
 526         }
 527
 528         r = sd_dhcp_server_start(link->dhcp_server);
 529         if (r < 0)
 530                 return log_link_error_errno(link, r, "Could not start DHCPv4 server instance: %m");
 531
 532         log_link_debug(link, "Offering DHCPv4 leases");
 533         return 0;
 534 }
 535
 536 static bool dhcp_server_is_ready_to_configure(Link *link) {
 537         Link *uplink = NULL;
 538         Address *a;
 539
 540         assert(link);
 541
 542         if (!link->network)
 543                 return false;
 544
 545         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
 546                 return false;
 547
 548         if (link->set_flags_messages > 0)
 549                 return false;
 550
 551         if (!link_has_carrier(link))
 552                 return false;
 553
 554         if (!link->static_addresses_configured)
 555                 return false;
 556
 557         if (link_find_dhcp_server_address(link, &a) < 0)
 558                 return false;
 559
 560         if (!address_is_ready(a))
 561                 return false;
 562
 563         if (dhcp_server_find_uplink(link, &uplink) < 0)
 564                 return false;
 565
 566         if (uplink && !uplink->network)
 567                 return false;
 568
 569         return true;
 570 }
 571
 572 static int dhcp_server_process_request(Request *req, Link *link, void *userdata) {
 573         int r;
 574
 575         assert(link);
 576
 577         if (!dhcp_server_is_ready_to_configure(link))
 578                 return 0;
 579
 580         r = dhcp4_server_configure(link);
 581         if (r < 0)
 582                 return log_link_warning_errno(link, r, "Failed to configure DHCP server: %m");
 583
 584         return 1;
 585 }
 586
 587 int link_request_dhcp_server(Link *link) {
 588         int r;
 589
 590         assert(link);
 591
 592         if (!link_dhcp4_server_enabled(link))
 593                 return 0;
 594
 595         if (link->dhcp_server)
 596                 return 0;
 597
 598         log_link_debug(link, "Requesting DHCP server.");
 599         r = link_queue_request(link, REQUEST_TYPE_DHCP_SERVER, dhcp_server_process_request, NULL);
 600         if (r < 0)
 601                 return log_link_warning_errno(link, r, "Failed to request configuration of DHCP server: %m");
 602
 603         return 0;
 604 }
 605
 606 int config_parse_dhcp_server_relay_agent_suboption(
 607                 const char *unit,
 608                 const char *filename,
 609                 unsigned line,
 610                 const char *section,
 611                 unsigned section_line,
 612                 const char *lvalue,
 613                 int ltype,
 614                 const char *rvalue,
 615                 void *data,
 616                 void *userdata) {
 617
 618         char **suboption_value = data;
 619         char* p;
 620
 621         assert(filename);
 622         assert(lvalue);
 623         assert(rvalue);
 624
 625         if (isempty(rvalue)) {
 626                 *suboption_value = mfree(*suboption_value);
 627                 return 0;
 628         }
 629
 630         p = startswith(rvalue, "string:");
 631         if (!p) {
 632                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 633                            "Failed to parse %s=%s'. Invalid format, ignoring.", lvalue, rvalue);
 634                 return 0;
 635         }
 636         return free_and_strdup(suboption_value, empty_to_null(p));
 637 }
 638
 639 int config_parse_dhcp_server_emit(
 640                 const char *unit,
 641                 const char *filename,
 642                 unsigned line,
 643                 const char *section,
 644                 unsigned section_line,
 645                 const char *lvalue,
 646                 int ltype,
 647                 const char *rvalue,
 648                 void *data,
 649                 void *userdata) {
 650
 651         NetworkDHCPServerEmitAddress *emit = data;
 652
 653         assert(emit);
 654         assert(rvalue);
 655
 656         if (isempty(rvalue)) {
 657                 emit->addresses = mfree(emit->addresses);
 658                 emit->n_addresses = 0;
 659                 return 0;
 660         }
 661
 662         for (const char *p = rvalue;;) {
 663                 _cleanup_free_ char *w = NULL;
 664                 union in_addr_union a;
 665                 int r;
 666
 667                 r = extract_first_word(&p, &w, NULL, 0);
 668                 if (r == -ENOMEM)
 669                         return log_oom();
 670                 if (r < 0) {
 671                         log_syntax(unit, LOG_WARNING, filename, line, r,
 672                                    "Failed to extract word, ignoring: %s", rvalue);
 673                         return 0;
 674                 }
 675                 if (r == 0)
 676                         return 0;
 677
 678                 if (streq(w, "_server_address"))
 679                         a = IN_ADDR_NULL; /* null address will be converted to the server address. */
 680                 else {
 681                         r = in_addr_from_string(AF_INET, w, &a);
 682                         if (r < 0) {
 683                                 log_syntax(unit, LOG_WARNING, filename, line, r,
 684                                            "Failed to parse %s= address '%s', ignoring: %m", lvalue, w);
 685                                 continue;
 686                         }
 687
 688                         if (in4_addr_is_null(&a.in)) {
 689                                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 690                                            "Found a null address in %s=, ignoring.", lvalue);
 691                                 continue;
 692                         }
 693                 }
 694
 695                 if (!GREEDY_REALLOC(emit->addresses, emit->n_addresses + 1))
 696                         return log_oom();
 697
 698                 emit->addresses[emit->n_addresses++] = a.in;
 699         }
 700 }
 701
 702 int config_parse_dhcp_server_address(
 703                 const char *unit,
 704                 const char *filename,
 705                 unsigned line,
 706                 const char *section,
 707                 unsigned section_line,
 708                 const char *lvalue,
 709                 int ltype,
 710                 const char *rvalue,
 711                 void *data,
 712                 void *userdata) {
 713
 714         Network *network = ASSERT_PTR(userdata);
 715         union in_addr_union a;
 716         unsigned char prefixlen;
 717         int r;
 718
 719         assert(filename);
 720         assert(lvalue);
 721         assert(rvalue);
 722
 723         if (isempty(rvalue)) {
 724                 network->dhcp_server_address = (struct in_addr) {};
 725                 network->dhcp_server_address_prefixlen = 0;
 726                 return 0;
 727         }
 728
 729         r = in_addr_prefix_from_string(rvalue, AF_INET, &a, &prefixlen);
 730         if (r < 0) {
 731                 log_syntax(unit, LOG_WARNING, filename, line, r,
 732                            "Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
 733                 return 0;
 734         }
 735         if (in4_addr_is_null(&a.in) || in4_addr_is_localhost(&a.in)) {
 736                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 737                            "DHCP server address cannot be the ANY address or a localhost address, "
 738                            "ignoring assignment: %s", rvalue);
 739                 return 0;
 740         }
 741
 742         network->dhcp_server_address = a.in;
 743         network->dhcp_server_address_prefixlen = prefixlen;
 744         return 0;
 745 }