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