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.h"
  13 #include "networkd-dhcp-server-bus.h"
  14 #include "networkd-link.h"
  15 #include "networkd-manager.h"
  16 #include "networkd-network.h"
  17 #include "parse-util.h"
  18 #include "socket-netlink.h"
  19 #include "string-table.h"
  20 #include "string-util.h"
  21 #include "strv.h"
  22
  23 static bool link_dhcp4_server_enabled(Link *link) {
  24         assert(link);
  25
  26         if (link->flags & IFF_LOOPBACK)
  27                 return false;
  28
  29         if (!link->network)
  30                 return false;
  31
  32         if (link->network->bond)
  33                 return false;
  34
  35         if (link->iftype == ARPHRD_CAN)
  36                 return false;
  37
  38         return link->network->dhcp_server;
  39 }
  40
  41 static Address* link_find_dhcp_server_address(Link *link) {
  42         Address *address;
  43
  44         assert(link);
  45         assert(link->network);
  46
  47         /* The first statically configured address if there is any */
  48         ORDERED_HASHMAP_FOREACH(address, link->network->addresses_by_section)
  49                 if (address->family == AF_INET &&
  50                     in_addr_is_set(address->family, &address->in_addr))
  51                         return address;
  52
  53         /* If that didn't work, find a suitable address we got from the pool */
  54         SET_FOREACH(address, link->pool_addresses)
  55                 if (address->family == AF_INET)
  56                         return address;
  57
  58         return NULL;
  59 }
  60
  61 static int link_push_uplink_to_dhcp_server(
  62                 Link *link,
  63                 sd_dhcp_lease_server_type_t what,
  64                 sd_dhcp_server *s) {
  65
  66         _cleanup_free_ struct in_addr *addresses = NULL;
  67         size_t n_addresses = 0, n_allocated = 0;
  68         bool use_dhcp_lease_data = true;
  69
  70         assert(link);
  71
  72         if (!link->network)
  73                 return 0;
  74         assert(link->network);
  75
  76         log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what));
  77
  78         switch (what) {
  79
  80         case SD_DHCP_LEASE_DNS:
  81                 /* For DNS we have a special case. We the data configured explicitly locally along with the
  82                  * data from the DHCP lease. */
  83
  84                 for (unsigned i = 0; i < link->network->n_dns; i++) {
  85                         struct in_addr ia;
  86
  87                         /* Only look for IPv4 addresses */
  88                         if (link->network->dns[i]->family != AF_INET)
  89                                 continue;
  90
  91                         ia = link->network->dns[i]->address.in;
  92
  93                         /* Never propagate obviously borked data */
  94                         if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia))
  95                                 continue;
  96
  97                         if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
  98                                 return log_oom();
  99
 100                         addresses[n_addresses++] = ia;
 101                 }
 102
 103                 use_dhcp_lease_data = link->network->dhcp_use_dns;
 104                 break;
 105
 106         case SD_DHCP_LEASE_NTP: {
 107                 char **i;
 108
 109                 /* For NTP things are similar, but for NTP hostnames can be configured too, which we cannot
 110                  * propagate via DHCP. Hence let's only propagate those which are IP addresses. */
 111
 112                 STRV_FOREACH(i, link->network->ntp) {
 113                         union in_addr_union ia;
 114
 115                         if (in_addr_from_string(AF_INET, *i, &ia) < 0)
 116                                 continue;
 117
 118                         /* Never propagate obviously borked data */
 119                         if (in4_addr_is_null(&ia.in) || in4_addr_is_localhost(&ia.in))
 120                                 continue;
 121
 122                         if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
 123                                 return log_oom();
 124
 125                         addresses[n_addresses++] = ia.in;
 126                 }
 127
 128                 use_dhcp_lease_data = link->network->dhcp_use_ntp;
 129                 break;
 130         }
 131
 132         case SD_DHCP_LEASE_SIP:
 133
 134                 /* For SIP we don't allow explicit, local configuration, but there's control whether to use the data */
 135                 use_dhcp_lease_data = link->network->dhcp_use_sip;
 136                 break;
 137
 138         case SD_DHCP_LEASE_POP3:
 139         case SD_DHCP_LEASE_SMTP:
 140         case SD_DHCP_LEASE_LPR:
 141                 /* For the other server types we currently do not allow local configuration of server data,
 142                  * since there are typically no local consumers of the data. */
 143                 break;
 144
 145         default:
 146                 assert_not_reached("Unexpected server type");
 147         }
 148
 149         if (use_dhcp_lease_data && link->dhcp_lease) {
 150                 const struct in_addr *da;
 151
 152                 int n = sd_dhcp_lease_get_servers(link->dhcp_lease, what, &da);
 153                 if (n > 0) {
 154                         if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + n))
 155                                 return log_oom();
 156
 157                         for (int j = 0; j < n; j++)
 158                                 if (in4_addr_is_non_local(&da[j]))
 159                                         addresses[n_addresses++] = da[j];
 160                 }
 161         }
 162
 163         if (n_addresses <= 0)
 164                 return 0;
 165
 166         return sd_dhcp_server_set_servers(s, what, addresses, n_addresses);
 167 }
 168
 169 static int dhcp4_server_parse_dns_server_string_and_warn(Link *l, const char *string, struct in_addr **addresses, size_t *n_allocated, size_t *n_addresses) {
 170         for (;;) {
 171                 _cleanup_free_ char *word = NULL, *server_name = NULL;
 172                 union in_addr_union address;
 173                 int family, r, ifindex = 0;
 174
 175                 r = extract_first_word(&string, &word, NULL, 0);
 176                 if (r < 0)
 177                         return r;
 178                 if (r == 0)
 179                         break;
 180
 181                 r = in_addr_ifindex_name_from_string_auto(word, &family, &address, &ifindex, &server_name);
 182                 if (r < 0) {
 183                         log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring: %m", word);
 184                         continue;
 185                 }
 186
 187                 /* Only look for IPv4 addresses */
 188                 if (family != AF_INET)
 189                         continue;
 190
 191                 /* Never propagate obviously borked data */
 192                 if (in4_addr_is_null(&address.in) || in4_addr_is_localhost(&address.in))
 193                         continue;
 194
 195                 if (!GREEDY_REALLOC(*addresses, *n_allocated, *n_addresses + 1))
 196                         return log_oom();
 197
 198                 (*addresses)[(*n_addresses)++] = address.in;
 199         }
 200
 201         return 0;
 202 }
 203
 204 static int dhcp4_server_set_dns_from_resolve_conf(Link *link) {
 205         _cleanup_free_ struct in_addr *addresses = NULL;
 206         size_t n_addresses = 0, n_allocated = 0;
 207         _cleanup_fclose_ FILE *f = NULL;
 208         int n = 0, r;
 209
 210         f = fopen(PRIVATE_UPLINK_RESOLV_CONF, "re");
 211         if (!f) {
 212                 if (errno == ENOENT)
 213                         return 0;
 214
 215                 return log_warning_errno(errno, "Failed to open " PRIVATE_UPLINK_RESOLV_CONF ": %m");
 216         }
 217
 218         for (;;) {
 219                 _cleanup_free_ char *line = NULL;
 220                 const char *a;
 221                 char *l;
 222
 223                 r = read_line(f, LONG_LINE_MAX, &line);
 224                 if (r < 0)
 225                         return log_error_errno(r, "Failed to read " PRIVATE_UPLINK_RESOLV_CONF ": %m");
 226                 if (r == 0)
 227                         break;
 228
 229                 n++;
 230
 231                 l = strstrip(line);
 232                 if (IN_SET(*l, '#', ';', 0))
 233                         continue;
 234
 235                 a = first_word(l, "nameserver");
 236                 if (!a)
 237                         continue;
 238
 239                 r = dhcp4_server_parse_dns_server_string_and_warn(link, a, &addresses, &n_allocated, &n_addresses);
 240                 if (r < 0)
 241                         log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring.", a);
 242         }
 243
 244         if (n_addresses <= 0)
 245                 return 0;
 246
 247         return sd_dhcp_server_set_dns(link->dhcp_server, addresses, n_addresses);
 248 }
 249
 250 int dhcp4_server_configure(Link *link) {
 251         bool acquired_uplink = false;
 252         sd_dhcp_option *p;
 253         Link *uplink = NULL;
 254         Address *address;
 255         int r;
 256
 257         assert(link);
 258
 259         if (!link_dhcp4_server_enabled(link))
 260                 return 0;
 261
 262         if (!(link->flags & IFF_UP))
 263                 return 0;
 264
 265         if (!link->dhcp_server) {
 266                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
 267                 if (r < 0)
 268                         return r;
 269
 270                 r = sd_dhcp_server_attach_event(link->dhcp_server, link->manager->event, 0);
 271                 if (r < 0)
 272                         return r;
 273         }
 274
 275         r = sd_dhcp_server_set_callback(link->dhcp_server, dhcp_server_callback, link);
 276         if (r < 0)
 277                 return log_link_warning_errno(link, r, "Failed to set callback for DHCPv4 server instance: %m");
 278
 279         address = link_find_dhcp_server_address(link);
 280         if (!address)
 281                 return log_link_error_errno(link, SYNTHETIC_ERRNO(EBUSY),
 282                                             "Failed to find suitable address for DHCPv4 server instance.");
 283
 284         /* use the server address' subnet as the pool */
 285         r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen,
 286                                           link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size);
 287         if (r < 0)
 288                 return log_link_error_errno(link, r, "Failed to configure address pool for DHCPv4 server instance: %m");
 289
 290         /* TODO:
 291         r = sd_dhcp_server_set_router(link->dhcp_server, &main_address->in_addr.in);
 292         if (r < 0)
 293                 return r;
 294         */
 295
 296         if (link->network->dhcp_server_max_lease_time_usec > 0) {
 297                 r = sd_dhcp_server_set_max_lease_time(link->dhcp_server,
 298                                                       DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
 299                 if (r < 0)
 300                         return log_link_error_errno(link, r, "Failed to set maximum lease time for DHCPv4 server instance: %m");
 301         }
 302
 303         if (link->network->dhcp_server_default_lease_time_usec > 0) {
 304                 r = sd_dhcp_server_set_default_lease_time(link->dhcp_server,
 305                                                           DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
 306                 if (r < 0)
 307                         return log_link_error_errno(link, r, "Failed to set default lease time for DHCPv4 server instance: %m");
 308         }
 309
 310         for (sd_dhcp_lease_server_type_t type = 0; type < _SD_DHCP_LEASE_SERVER_TYPE_MAX; type ++) {
 311
 312                 if (!link->network->dhcp_server_emit[type].emit)
 313                         continue;
 314
 315                 if (link->network->dhcp_server_emit[type].n_addresses > 0)
 316                         /* Explicitly specified servers to emit */
 317                         r = sd_dhcp_server_set_servers(
 318                                         link->dhcp_server,
 319                                         type,
 320                                         link->network->dhcp_server_emit[type].addresses,
 321                                         link->network->dhcp_server_emit[type].n_addresses);
 322                 else {
 323                         /* Emission is requested, but nothing explicitly configured. Let's find a suitable upling */
 324                         if (!acquired_uplink) {
 325                                 uplink = manager_find_uplink(link->manager, link);
 326                                 acquired_uplink = true;
 327                         }
 328
 329                         if (uplink && uplink->network)
 330                                 r = link_push_uplink_to_dhcp_server(uplink, type, link->dhcp_server);
 331                         else if (type == SD_DHCP_LEASE_DNS)
 332                                 r = dhcp4_server_set_dns_from_resolve_conf(link);
 333                         else {
 334                                 log_link_debug(link,
 335                                                "Not emitting %s on link, couldn't find suitable uplink.",
 336                                                dhcp_lease_server_type_to_string(type));
 337                                 continue;
 338                         }
 339                 }
 340
 341                 if (r < 0)
 342                         log_link_warning_errno(link, r,
 343                                                "Failed to set %s for DHCP server, ignoring: %m",
 344                                                dhcp_lease_server_type_to_string(type));
 345         }
 346
 347         r = sd_dhcp_server_set_bind_to_interface(link->dhcp_server, link->network->dhcp_server_bind_to_interface);
 348         if (r < 0)
 349                 return log_link_error_errno(link, r, "Failed to set interface binding for DHCP server: %m");
 350
 351         r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);
 352         if (r < 0)
 353                 return log_link_error_errno(link, r, "Failed to set router emission for DHCP server: %m");
 354
 355         r = sd_dhcp_server_set_relay_target(link->dhcp_server, &link->network->dhcp_server_relay_target);
 356         if (r < 0)
 357                 return log_link_error_errno(link, r, "Failed to set relay target for DHCP server: %m");
 358
 359         if (link->network->dhcp_server_emit_timezone) {
 360                 _cleanup_free_ char *buffer = NULL;
 361                 const char *tz;
 362
 363                 if (link->network->dhcp_server_timezone)
 364                         tz = link->network->dhcp_server_timezone;
 365                 else {
 366                         r = get_timezone(&buffer);
 367                         if (r < 0)
 368                                 return log_link_error_errno(link, r, "Failed to determine timezone: %m");
 369
 370                         tz = buffer;
 371                 }
 372
 373                 r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
 374                 if (r < 0)
 375                         return log_link_error_errno(link, r, "Failed to set timezone for DHCP server: %m");
 376         }
 377
 378         ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options) {
 379                 r = sd_dhcp_server_add_option(link->dhcp_server, p);
 380                 if (r == -EEXIST)
 381                         continue;
 382                 if (r < 0)
 383                         return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
 384         }
 385
 386         ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options) {
 387                 r = sd_dhcp_server_add_vendor_option(link->dhcp_server, p);
 388                 if (r == -EEXIST)
 389                         continue;
 390                 if (r < 0)
 391                         return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
 392         }
 393
 394         if (!sd_dhcp_server_is_running(link->dhcp_server)) {
 395                 r = sd_dhcp_server_start(link->dhcp_server);
 396                 if (r < 0)
 397                         return log_link_error_errno(link, r, "Could not start DHCPv4 server instance: %m");
 398
 399                 log_link_debug(link, "Offering DHCPv4 leases");
 400         }
 401
 402         return 0;
 403 }
 404
 405 int config_parse_dhcp_server_relay_target(
 406                 const char *unit,
 407                 const char *filename,
 408                 unsigned line,
 409                 const char *section,
 410                 unsigned section_line,
 411                 const char *lvalue,
 412                 int ltype,
 413                 const char *rvalue,
 414                 void *data,
 415                 void *userdata) {
 416
 417         Network *network = userdata;
 418         union in_addr_union a;
 419         int r;
 420
 421         r = in_addr_from_string(AF_INET, rvalue, &a);
 422         if (r < 0) {
 423                 log_syntax(unit, LOG_WARNING, filename, line, r,
 424                            "Failed to parse %s= address '%s', ignoring: %m", lvalue, rvalue);
 425                 return 0;
 426         }
 427         network->dhcp_server_relay_target = a.in;
 428         return r;
 429 }
 430
 431 int config_parse_dhcp_server_emit(
 432                 const char *unit,
 433                 const char *filename,
 434                 unsigned line,
 435                 const char *section,
 436                 unsigned section_line,
 437                 const char *lvalue,
 438                 int ltype,
 439                 const char *rvalue,
 440                 void *data,
 441                 void *userdata) {
 442
 443         NetworkDHCPServerEmitAddress *emit = data;
 444
 445         assert(emit);
 446         assert(rvalue);
 447
 448         for (const char *p = rvalue;;) {
 449                 _cleanup_free_ char *w = NULL;
 450                 union in_addr_union a;
 451                 int r;
 452
 453                 r = extract_first_word(&p, &w, NULL, 0);
 454                 if (r == -ENOMEM)
 455                         return log_oom();
 456                 if (r < 0) {
 457                         log_syntax(unit, LOG_WARNING, filename, line, r,
 458                                    "Failed to extract word, ignoring: %s", rvalue);
 459                         return 0;
 460                 }
 461                 if (r == 0)
 462                         return 0;
 463
 464                 r = in_addr_from_string(AF_INET, w, &a);
 465                 if (r < 0) {
 466                         log_syntax(unit, LOG_WARNING, filename, line, r,
 467                                    "Failed to parse %s= address '%s', ignoring: %m", lvalue, w);
 468                         continue;
 469                 }
 470
 471                 struct in_addr *m = reallocarray(emit->addresses, emit->n_addresses + 1, sizeof(struct in_addr));
 472                 if (!m)
 473                         return log_oom();
 474
 475                 emit->addresses = m;
 476                 emit->addresses[emit->n_addresses++] = a.in;
 477         }
 478 }