src/libsystemd-network/sd-dhcp-lease.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2013 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <arpa/inet.h>
   7 #include <errno.h>
   8 #include <stdio.h>
   9 #include <stdio_ext.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "sd-dhcp-lease.h"
  14
  15 #include "alloc-util.h"
  16 #include "dhcp-lease-internal.h"
  17 #include "dhcp-protocol.h"
  18 #include "dns-domain.h"
  19 #include "env-file.h"
  20 #include "fd-util.h"
  21 #include "fileio.h"
  22 #include "hexdecoct.h"
  23 #include "hostname-util.h"
  24 #include "in-addr-util.h"
  25 #include "network-internal.h"
  26 #include "parse-util.h"
  27 #include "stdio-util.h"
  28 #include "string-util.h"
  29 #include "strv.h"
  30 #include "tmpfile-util.h"
  31 #include "unaligned.h"
  32
  33 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr) {
  34         assert_return(lease, -EINVAL);
  35         assert_return(addr, -EINVAL);
  36
  37         if (lease->address == 0)
  38                 return -ENODATA;
  39
  40         addr->s_addr = lease->address;
  41         return 0;
  42 }
  43
  44 int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr) {
  45         assert_return(lease, -EINVAL);
  46         assert_return(addr, -EINVAL);
  47
  48         if (!lease->have_broadcast)
  49                 return -ENODATA;
  50
  51         addr->s_addr = lease->broadcast;
  52         return 0;
  53 }
  54
  55 int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime) {
  56         assert_return(lease, -EINVAL);
  57         assert_return(lifetime, -EINVAL);
  58
  59         if (lease->lifetime <= 0)
  60                 return -ENODATA;
  61
  62         *lifetime = lease->lifetime;
  63         return 0;
  64 }
  65
  66 int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1) {
  67         assert_return(lease, -EINVAL);
  68         assert_return(t1, -EINVAL);
  69
  70         if (lease->t1 <= 0)
  71                 return -ENODATA;
  72
  73         *t1 = lease->t1;
  74         return 0;
  75 }
  76
  77 int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2) {
  78         assert_return(lease, -EINVAL);
  79         assert_return(t2, -EINVAL);
  80
  81         if (lease->t2 <= 0)
  82                 return -ENODATA;
  83
  84         *t2 = lease->t2;
  85         return 0;
  86 }
  87
  88 int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
  89         assert_return(lease, -EINVAL);
  90         assert_return(mtu, -EINVAL);
  91
  92         if (lease->mtu <= 0)
  93                 return -ENODATA;
  94
  95         *mtu = lease->mtu;
  96         return 0;
  97 }
  98
  99 int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr) {
 100         assert_return(lease, -EINVAL);
 101         assert_return(addr, -EINVAL);
 102
 103         if (lease->dns_size <= 0)
 104                 return -ENODATA;
 105
 106         *addr = lease->dns;
 107         return (int) lease->dns_size;
 108 }
 109
 110 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr) {
 111         assert_return(lease, -EINVAL);
 112         assert_return(addr, -EINVAL);
 113
 114         if (lease->ntp_size <= 0)
 115                 return -ENODATA;
 116
 117         *addr = lease->ntp;
 118         return (int) lease->ntp_size;
 119 }
 120
 121 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname) {
 122         assert_return(lease, -EINVAL);
 123         assert_return(domainname, -EINVAL);
 124
 125         if (!lease->domainname)
 126                 return -ENODATA;
 127
 128         *domainname = lease->domainname;
 129         return 0;
 130 }
 131
 132 int sd_dhcp_lease_get_hostname(sd_dhcp_lease *lease, const char **hostname) {
 133         assert_return(lease, -EINVAL);
 134         assert_return(hostname, -EINVAL);
 135
 136         if (!lease->hostname)
 137                 return -ENODATA;
 138
 139         *hostname = lease->hostname;
 140         return 0;
 141 }
 142
 143 int sd_dhcp_lease_get_root_path(sd_dhcp_lease *lease, const char **root_path) {
 144         assert_return(lease, -EINVAL);
 145         assert_return(root_path, -EINVAL);
 146
 147         if (!lease->root_path)
 148                 return -ENODATA;
 149
 150         *root_path = lease->root_path;
 151         return 0;
 152 }
 153
 154 int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, struct in_addr *addr) {
 155         assert_return(lease, -EINVAL);
 156         assert_return(addr, -EINVAL);
 157
 158         if (lease->router == 0)
 159                 return -ENODATA;
 160
 161         addr->s_addr = lease->router;
 162         return 0;
 163 }
 164
 165 int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr) {
 166         assert_return(lease, -EINVAL);
 167         assert_return(addr, -EINVAL);
 168
 169         if (!lease->have_subnet_mask)
 170                 return -ENODATA;
 171
 172         addr->s_addr = lease->subnet_mask;
 173         return 0;
 174 }
 175
 176 int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *addr) {
 177         assert_return(lease, -EINVAL);
 178         assert_return(addr, -EINVAL);
 179
 180         if (lease->server_address == 0)
 181                 return -ENODATA;
 182
 183         addr->s_addr = lease->server_address;
 184         return 0;
 185 }
 186
 187 int sd_dhcp_lease_get_next_server(sd_dhcp_lease *lease, struct in_addr *addr) {
 188         assert_return(lease, -EINVAL);
 189         assert_return(addr, -EINVAL);
 190
 191         if (lease->next_server == 0)
 192                 return -ENODATA;
 193
 194         addr->s_addr = lease->next_server;
 195         return 0;
 196 }
 197
 198 /*
 199  * The returned routes array must be freed by the caller.
 200  * Route objects have the same lifetime of the lease and must not be freed.
 201  */
 202 int sd_dhcp_lease_get_routes(sd_dhcp_lease *lease, sd_dhcp_route ***routes) {
 203         sd_dhcp_route **ret;
 204         unsigned i;
 205
 206         assert_return(lease, -EINVAL);
 207         assert_return(routes, -EINVAL);
 208
 209         if (lease->static_route_size <= 0)
 210                 return -ENODATA;
 211
 212         ret = new(sd_dhcp_route *, lease->static_route_size);
 213         if (!ret)
 214                 return -ENOMEM;
 215
 216         for (i = 0; i < lease->static_route_size; i++)
 217                 ret[i] = &lease->static_route[i];
 218
 219         *routes = ret;
 220         return (int) lease->static_route_size;
 221 }
 222
 223 int sd_dhcp_lease_get_search_domains(sd_dhcp_lease *lease, char ***domains) {
 224         size_t r;
 225
 226         assert_return(lease, -EINVAL);
 227         assert_return(domains, -EINVAL);
 228
 229         r = strv_length(lease->search_domains);
 230         if (r > 0) {
 231                 *domains = lease->search_domains;
 232                 return (int) r;
 233         }
 234
 235         return -ENODATA;
 236 }
 237
 238 int sd_dhcp_lease_get_vendor_specific(sd_dhcp_lease *lease, const void **data, size_t *data_len) {
 239         assert_return(lease, -EINVAL);
 240         assert_return(data, -EINVAL);
 241         assert_return(data_len, -EINVAL);
 242
 243         if (lease->vendor_specific_len <= 0)
 244                 return -ENODATA;
 245
 246         *data = lease->vendor_specific;
 247         *data_len = lease->vendor_specific_len;
 248         return 0;
 249 }
 250
 251 static sd_dhcp_lease *dhcp_lease_free(sd_dhcp_lease *lease) {
 252         assert(lease);
 253
 254         while (lease->private_options) {
 255                 struct sd_dhcp_raw_option *option = lease->private_options;
 256
 257                 LIST_REMOVE(options, lease->private_options, option);
 258
 259                 free(option->data);
 260                 free(option);
 261         }
 262
 263         free(lease->root_path);
 264         free(lease->timezone);
 265         free(lease->hostname);
 266         free(lease->domainname);
 267         free(lease->dns);
 268         free(lease->ntp);
 269         free(lease->static_route);
 270         free(lease->client_id);
 271         free(lease->vendor_specific);
 272         strv_free(lease->search_domains);
 273         return mfree(lease);
 274 }
 275
 276 DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_lease, sd_dhcp_lease, dhcp_lease_free);
 277
 278 static int lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_t min) {
 279         assert(option);
 280         assert(ret);
 281
 282         if (len != 4)
 283                 return -EINVAL;
 284
 285         *ret = unaligned_read_be32((be32_t*) option);
 286         if (*ret < min)
 287                 *ret = min;
 288
 289         return 0;
 290 }
 291
 292 static int lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
 293         assert(option);
 294         assert(ret);
 295
 296         if (len != 2)
 297                 return -EINVAL;
 298
 299         *ret = unaligned_read_be16((be16_t*) option);
 300         if (*ret < min)
 301                 *ret = min;
 302
 303         return 0;
 304 }
 305
 306 static int lease_parse_be32(const uint8_t *option, size_t len, be32_t *ret) {
 307         assert(option);
 308         assert(ret);
 309
 310         if (len != 4)
 311                 return -EINVAL;
 312
 313         memcpy(ret, option, 4);
 314         return 0;
 315 }
 316
 317 static int lease_parse_string(const uint8_t *option, size_t len, char **ret) {
 318         assert(option);
 319         assert(ret);
 320
 321         if (len <= 0)
 322                 *ret = mfree(*ret);
 323         else {
 324                 char *string;
 325
 326                 /*
 327                  * One trailing NUL byte is OK, we don't mind. See:
 328                  * https://github.com/systemd/systemd/issues/1337
 329                  */
 330                 if (memchr(option, 0, len - 1))
 331                         return -EINVAL;
 332
 333                 string = strndup((const char *) option, len);
 334                 if (!string)
 335                         return -ENOMEM;
 336
 337                 free_and_replace(*ret, string);
 338         }
 339
 340         return 0;
 341 }
 342
 343 static int lease_parse_domain(const uint8_t *option, size_t len, char **ret) {
 344         _cleanup_free_ char *name = NULL, *normalized = NULL;
 345         int r;
 346
 347         assert(option);
 348         assert(ret);
 349
 350         r = lease_parse_string(option, len, &name);
 351         if (r < 0)
 352                 return r;
 353         if (!name) {
 354                 *ret = mfree(*ret);
 355                 return 0;
 356         }
 357
 358         r = dns_name_normalize(name, 0, &normalized);
 359         if (r < 0)
 360                 return r;
 361
 362         if (is_localhost(normalized))
 363                 return -EINVAL;
 364
 365         if (dns_name_is_root(normalized))
 366                 return -EINVAL;
 367
 368         free_and_replace(*ret, normalized);
 369
 370         return 0;
 371 }
 372
 373 static void filter_bogus_addresses(struct in_addr *addresses, size_t *n) {
 374         size_t i, j;
 375
 376         /* Silently filter DNS/NTP servers supplied to us that do not make outside of the local scope. */
 377
 378         for (i = 0, j = 0; i < *n; i ++) {
 379
 380                 if (in4_addr_is_null(addresses+i) ||
 381                     in4_addr_is_localhost(addresses+i))
 382                         continue;
 383
 384                 addresses[j++] = addresses[i];
 385         }
 386
 387         *n = j;
 388 }
 389
 390 static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
 391         assert(option);
 392         assert(ret);
 393         assert(n_ret);
 394
 395         if (len <= 0) {
 396                 *ret = mfree(*ret);
 397                 *n_ret = 0;
 398         } else {
 399                 size_t n_addresses;
 400                 struct in_addr *addresses;
 401
 402                 if (len % 4 != 0)
 403                         return -EINVAL;
 404
 405                 n_addresses = len / 4;
 406
 407                 addresses = newdup(struct in_addr, option, n_addresses);
 408                 if (!addresses)
 409                         return -ENOMEM;
 410
 411                 filter_bogus_addresses(addresses, &n_addresses);
 412
 413                 free(*ret);
 414                 *ret = addresses;
 415                 *n_ret = n_addresses;
 416         }
 417
 418         return 0;
 419 }
 420
 421 static int lease_parse_routes(
 422                 const uint8_t *option, size_t len,
 423                 struct sd_dhcp_route **routes, size_t *routes_size, size_t *routes_allocated) {
 424
 425         struct in_addr addr;
 426
 427         assert(option || len <= 0);
 428         assert(routes);
 429         assert(routes_size);
 430         assert(routes_allocated);
 431
 432         if (len <= 0)
 433                 return 0;
 434
 435         if (len % 8 != 0)
 436                 return -EINVAL;
 437
 438         if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + (len / 8)))
 439                 return -ENOMEM;
 440
 441         while (len >= 8) {
 442                 struct sd_dhcp_route *route = *routes + *routes_size;
 443                 int r;
 444
 445                 route->option = SD_DHCP_OPTION_STATIC_ROUTE;
 446                 r = in4_addr_default_prefixlen((struct in_addr*) option, &route->dst_prefixlen);
 447                 if (r < 0) {
 448                         log_debug("Failed to determine destination prefix length from class based IP, ignoring");
 449                         continue;
 450                 }
 451
 452                 assert_se(lease_parse_be32(option, 4, &addr.s_addr) >= 0);
 453                 route->dst_addr = inet_makeaddr(inet_netof(addr), 0);
 454                 option += 4;
 455
 456                 assert_se(lease_parse_be32(option, 4, &route->gw_addr.s_addr) >= 0);
 457                 option += 4;
 458
 459                 len -= 8;
 460                 (*routes_size)++;
 461         }
 462
 463         return 0;
 464 }
 465
 466 /* parses RFC3442 Classless Static Route Option */
 467 static int lease_parse_classless_routes(
 468                 const uint8_t *option, size_t len,
 469                 struct sd_dhcp_route **routes, size_t *routes_size, size_t *routes_allocated) {
 470
 471         assert(option || len <= 0);
 472         assert(routes);
 473         assert(routes_size);
 474         assert(routes_allocated);
 475
 476         if (len <= 0)
 477                 return 0;
 478
 479         /* option format: (subnet-mask-width significant-subnet-octets gateway-ip)*  */
 480
 481         while (len > 0) {
 482                 uint8_t dst_octets;
 483                 struct sd_dhcp_route *route;
 484
 485                 if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + 1))
 486                         return -ENOMEM;
 487
 488                 route = *routes + *routes_size;
 489                 route->option = SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE;
 490
 491                 dst_octets = (*option == 0 ? 0 : ((*option - 1) / 8) + 1);
 492                 route->dst_prefixlen = *option;
 493                 option++;
 494                 len--;
 495
 496                 /* can't have more than 4 octets in IPv4 */
 497                 if (dst_octets > 4 || len < dst_octets)
 498                         return -EINVAL;
 499
 500                 route->dst_addr.s_addr = 0;
 501                 memcpy(&route->dst_addr.s_addr, option, dst_octets);
 502                 option += dst_octets;
 503                 len -= dst_octets;
 504
 505                 if (len < 4)
 506                         return -EINVAL;
 507
 508                 assert_se(lease_parse_be32(option, 4, &route->gw_addr.s_addr) >= 0);
 509                 option += 4;
 510                 len -= 4;
 511
 512                 (*routes_size)++;
 513         }
 514
 515         return 0;
 516 }
 517
 518 int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
 519         sd_dhcp_lease *lease = userdata;
 520         int r;
 521
 522         assert(lease);
 523
 524         switch(code) {
 525
 526         case SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
 527                 r = lease_parse_u32(option, len, &lease->lifetime, 1);
 528                 if (r < 0)
 529                         log_debug_errno(r, "Failed to parse lease time, ignoring: %m");
 530
 531                 break;
 532
 533         case SD_DHCP_OPTION_SERVER_IDENTIFIER:
 534                 r = lease_parse_be32(option, len, &lease->server_address);
 535                 if (r < 0)
 536                         log_debug_errno(r, "Failed to parse server identifier, ignoring: %m");
 537
 538                 break;
 539
 540         case SD_DHCP_OPTION_SUBNET_MASK:
 541                 r = lease_parse_be32(option, len, &lease->subnet_mask);
 542                 if (r < 0)
 543                         log_debug_errno(r, "Failed to parse subnet mask, ignoring: %m");
 544                 else
 545                         lease->have_subnet_mask = true;
 546                 break;
 547
 548         case SD_DHCP_OPTION_BROADCAST:
 549                 r = lease_parse_be32(option, len, &lease->broadcast);
 550                 if (r < 0)
 551                         log_debug_errno(r, "Failed to parse broadcast address, ignoring: %m");
 552                 else
 553                         lease->have_broadcast = true;
 554                 break;
 555
 556         case SD_DHCP_OPTION_ROUTER:
 557                 if (len >= 4) {
 558                         r = lease_parse_be32(option, 4, &lease->router);
 559                         if (r < 0)
 560                                 log_debug_errno(r, "Failed to parse router address, ignoring: %m");
 561                 }
 562                 break;
 563
 564         case SD_DHCP_OPTION_DOMAIN_NAME_SERVER:
 565                 r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
 566                 if (r < 0)
 567                         log_debug_errno(r, "Failed to parse DNS server, ignoring: %m");
 568                 break;
 569
 570         case SD_DHCP_OPTION_NTP_SERVER:
 571                 r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
 572                 if (r < 0)
 573                         log_debug_errno(r, "Failed to parse NTP server, ignoring: %m");
 574                 break;
 575
 576         case SD_DHCP_OPTION_STATIC_ROUTE:
 577                 r = lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size, &lease->static_route_allocated);
 578                 if (r < 0)
 579                         log_debug_errno(r, "Failed to parse static routes, ignoring: %m");
 580                 break;
 581
 582         case SD_DHCP_OPTION_INTERFACE_MTU:
 583                 r = lease_parse_u16(option, len, &lease->mtu, 68);
 584                 if (r < 0)
 585                         log_debug_errno(r, "Failed to parse MTU, ignoring: %m");
 586                 if (lease->mtu < DHCP_DEFAULT_MIN_SIZE) {
 587                         log_debug("MTU value of %" PRIu16 " too small. Using default MTU value of %d instead.", lease->mtu, DHCP_DEFAULT_MIN_SIZE);
 588                         lease->mtu = DHCP_DEFAULT_MIN_SIZE;
 589                 }
 590
 591                 break;
 592
 593         case SD_DHCP_OPTION_DOMAIN_NAME:
 594                 r = lease_parse_domain(option, len, &lease->domainname);
 595                 if (r < 0) {
 596                         log_debug_errno(r, "Failed to parse domain name, ignoring: %m");
 597                         return 0;
 598                 }
 599
 600                 break;
 601
 602         case SD_DHCP_OPTION_DOMAIN_SEARCH_LIST:
 603                 r = dhcp_lease_parse_search_domains(option, len, &lease->search_domains);
 604                 if (r < 0)
 605                         log_debug_errno(r, "Failed to parse Domain Search List, ignoring: %m");
 606                 break;
 607
 608         case SD_DHCP_OPTION_HOST_NAME:
 609                 r = lease_parse_domain(option, len, &lease->hostname);
 610                 if (r < 0) {
 611                         log_debug_errno(r, "Failed to parse host name, ignoring: %m");
 612                         return 0;
 613                 }
 614
 615                 break;
 616
 617         case SD_DHCP_OPTION_ROOT_PATH:
 618                 r = lease_parse_string(option, len, &lease->root_path);
 619                 if (r < 0)
 620                         log_debug_errno(r, "Failed to parse root path, ignoring: %m");
 621                 break;
 622
 623         case SD_DHCP_OPTION_RENEWAL_T1_TIME:
 624                 r = lease_parse_u32(option, len, &lease->t1, 1);
 625                 if (r < 0)
 626                         log_debug_errno(r, "Failed to parse T1 time, ignoring: %m");
 627                 break;
 628
 629         case SD_DHCP_OPTION_REBINDING_T2_TIME:
 630                 r = lease_parse_u32(option, len, &lease->t2, 1);
 631                 if (r < 0)
 632                         log_debug_errno(r, "Failed to parse T2 time, ignoring: %m");
 633                 break;
 634
 635         case SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
 636                 r = lease_parse_classless_routes(
 637                                 option, len,
 638                                 &lease->static_route,
 639                                 &lease->static_route_size,
 640                                 &lease->static_route_allocated);
 641                 if (r < 0)
 642                         log_debug_errno(r, "Failed to parse classless routes, ignoring: %m");
 643                 break;
 644
 645         case SD_DHCP_OPTION_NEW_TZDB_TIMEZONE: {
 646                 _cleanup_free_ char *tz = NULL;
 647
 648                 r = lease_parse_string(option, len, &tz);
 649                 if (r < 0) {
 650                         log_debug_errno(r, "Failed to parse timezone option, ignoring: %m");
 651                         return 0;
 652                 }
 653
 654                 if (!timezone_is_valid(tz, LOG_DEBUG)) {
 655                         log_debug_errno(r, "Timezone is not valid, ignoring: %m");
 656                         return 0;
 657                 }
 658
 659                 free_and_replace(lease->timezone, tz);
 660
 661                 break;
 662         }
 663
 664         case SD_DHCP_OPTION_VENDOR_SPECIFIC:
 665
 666                 if (len <= 0)
 667                         lease->vendor_specific = mfree(lease->vendor_specific);
 668                 else {
 669                         void *p;
 670
 671                         p = memdup(option, len);
 672                         if (!p)
 673                                 return -ENOMEM;
 674
 675                         free(lease->vendor_specific);
 676                         lease->vendor_specific = p;
 677                 }
 678
 679                 lease->vendor_specific_len = len;
 680                 break;
 681
 682         case SD_DHCP_OPTION_PRIVATE_BASE ... SD_DHCP_OPTION_PRIVATE_LAST:
 683                 r = dhcp_lease_insert_private_option(lease, code, option, len);
 684                 if (r < 0)
 685                         return r;
 686
 687                 break;
 688
 689         default:
 690                 log_debug("Ignoring option DHCP option %"PRIu8" while parsing.", code);
 691                 break;
 692         }
 693
 694         return 0;
 695 }
 696
 697 /* Parses compressed domain names. */
 698 int dhcp_lease_parse_search_domains(const uint8_t *option, size_t len, char ***domains) {
 699         _cleanup_strv_free_ char **names = NULL;
 700         size_t pos = 0, cnt = 0;
 701         int r;
 702
 703         assert(domains);
 704         assert_return(option && len > 0, -ENODATA);
 705
 706         while (pos < len) {
 707                 _cleanup_free_ char *name = NULL;
 708                 size_t n = 0, allocated = 0;
 709                 size_t jump_barrier = pos, next_chunk = 0;
 710                 bool first = true;
 711
 712                 for (;;) {
 713                         uint8_t c;
 714                         c = option[pos++];
 715
 716                         if (c == 0) {
 717                                 /* End of name */
 718                                 break;
 719                         } else if (c <= 63) {
 720                                 const char *label;
 721
 722                                 /* Literal label */
 723                                 label = (const char*) (option + pos);
 724                                 pos += c;
 725                                 if (pos >= len)
 726                                         return -EBADMSG;
 727
 728                                 if (!GREEDY_REALLOC(name, allocated, n + !first + DNS_LABEL_ESCAPED_MAX))
 729                                         return -ENOMEM;
 730
 731                                 if (first)
 732                                         first = false;
 733                                 else
 734                                         name[n++] = '.';
 735
 736                                 r = dns_label_escape(label, c, name + n, DNS_LABEL_ESCAPED_MAX);
 737                                 if (r < 0)
 738                                         return r;
 739
 740                                 n += r;
 741                         } else if ((c & 0xc0) == 0xc0) {
 742                                 /* Pointer */
 743
 744                                 uint8_t d;
 745                                 uint16_t ptr;
 746
 747                                 if (pos >= len)
 748                                         return -EBADMSG;
 749
 750                                 d = option[pos++];
 751                                 ptr = (uint16_t) (c & ~0xc0) << 8 | (uint16_t) d;
 752
 753                                 /* Jumps are limited to a "prior occurrence" (RFC-1035 4.1.4) */
 754                                 if (ptr >= jump_barrier)
 755                                         return -EBADMSG;
 756                                 jump_barrier = ptr;
 757
 758                                 /* Save current location so we don't end up re-parsing what's parsed so far. */
 759                                 if (next_chunk == 0)
 760                                         next_chunk = pos;
 761
 762                                 pos = ptr;
 763                         } else
 764                                 return -EBADMSG;
 765                 }
 766
 767                 if (!GREEDY_REALLOC(name, allocated, n + 1))
 768                         return -ENOMEM;
 769                 name[n] = 0;
 770
 771                 r = strv_extend(&names, name);
 772                 if (r < 0)
 773                         return r;
 774
 775                 cnt++;
 776
 777                 if (next_chunk != 0)
 778                       pos = next_chunk;
 779         }
 780
 781         *domains = TAKE_PTR(names);
 782
 783         return cnt;
 784 }
 785
 786 int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag, const void *data, uint8_t len) {
 787         struct sd_dhcp_raw_option *cur, *option;
 788
 789         assert(lease);
 790
 791         LIST_FOREACH(options, cur, lease->private_options) {
 792                 if (tag < cur->tag)
 793                         break;
 794                 if (tag == cur->tag) {
 795                         log_debug("Ignoring duplicate option, tagged %i.", tag);
 796                         return 0;
 797                 }
 798         }
 799
 800         option = new(struct sd_dhcp_raw_option, 1);
 801         if (!option)
 802                 return -ENOMEM;
 803
 804         option->tag = tag;
 805         option->length = len;
 806         option->data = memdup(data, len);
 807         if (!option->data) {
 808                 free(option);
 809                 return -ENOMEM;
 810         }
 811
 812         LIST_INSERT_BEFORE(options, lease->private_options, cur, option);
 813         return 0;
 814 }
 815
 816 int dhcp_lease_new(sd_dhcp_lease **ret) {
 817         sd_dhcp_lease *lease;
 818
 819         lease = new0(sd_dhcp_lease, 1);
 820         if (!lease)
 821                 return -ENOMEM;
 822
 823         lease->router = INADDR_ANY;
 824         lease->n_ref = 1;
 825
 826         *ret = lease;
 827         return 0;
 828 }
 829
 830 int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
 831         _cleanup_free_ char *temp_path = NULL;
 832         _cleanup_fclose_ FILE *f = NULL;
 833         struct sd_dhcp_raw_option *option;
 834         struct in_addr address;
 835         const struct in_addr *addresses;
 836         const void *client_id, *data;
 837         size_t client_id_len, data_len;
 838         const char *string;
 839         uint16_t mtu;
 840         _cleanup_free_ sd_dhcp_route **routes = NULL;
 841         char **search_domains = NULL;
 842         uint32_t t1, t2, lifetime;
 843         int r;
 844
 845         assert(lease);
 846         assert(lease_file);
 847
 848         r = fopen_temporary(lease_file, &f, &temp_path);
 849         if (r < 0)
 850                 goto fail;
 851
 852         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
 853         (void) fchmod(fileno(f), 0644);
 854
 855         fprintf(f,
 856                 "# This is private data. Do not parse.\n");
 857
 858         r = sd_dhcp_lease_get_address(lease, &address);
 859         if (r >= 0)
 860                 fprintf(f, "ADDRESS=%s\n", inet_ntoa(address));
 861
 862         r = sd_dhcp_lease_get_netmask(lease, &address);
 863         if (r >= 0)
 864                 fprintf(f, "NETMASK=%s\n", inet_ntoa(address));
 865
 866         r = sd_dhcp_lease_get_router(lease, &address);
 867         if (r >= 0)
 868                 fprintf(f, "ROUTER=%s\n", inet_ntoa(address));
 869
 870         r = sd_dhcp_lease_get_server_identifier(lease, &address);
 871         if (r >= 0)
 872                 fprintf(f, "SERVER_ADDRESS=%s\n", inet_ntoa(address));
 873
 874         r = sd_dhcp_lease_get_next_server(lease, &address);
 875         if (r >= 0)
 876                 fprintf(f, "NEXT_SERVER=%s\n", inet_ntoa(address));
 877
 878         r = sd_dhcp_lease_get_broadcast(lease, &address);
 879         if (r >= 0)
 880                 fprintf(f, "BROADCAST=%s\n", inet_ntoa(address));
 881
 882         r = sd_dhcp_lease_get_mtu(lease, &mtu);
 883         if (r >= 0)
 884                 fprintf(f, "MTU=%" PRIu16 "\n", mtu);
 885
 886         r = sd_dhcp_lease_get_t1(lease, &t1);
 887         if (r >= 0)
 888                 fprintf(f, "T1=%" PRIu32 "\n", t1);
 889
 890         r = sd_dhcp_lease_get_t2(lease, &t2);
 891         if (r >= 0)
 892                 fprintf(f, "T2=%" PRIu32 "\n", t2);
 893
 894         r = sd_dhcp_lease_get_lifetime(lease, &lifetime);
 895         if (r >= 0)
 896                 fprintf(f, "LIFETIME=%" PRIu32 "\n", lifetime);
 897
 898         r = sd_dhcp_lease_get_dns(lease, &addresses);
 899         if (r > 0) {
 900                 fputs("DNS=", f);
 901                 serialize_in_addrs(f, addresses, r);
 902                 fputs("\n", f);
 903         }
 904
 905         r = sd_dhcp_lease_get_ntp(lease, &addresses);
 906         if (r > 0) {
 907                 fputs("NTP=", f);
 908                 serialize_in_addrs(f, addresses, r);
 909                 fputs("\n", f);
 910         }
 911
 912         r = sd_dhcp_lease_get_domainname(lease, &string);
 913         if (r >= 0)
 914                 fprintf(f, "DOMAINNAME=%s\n", string);
 915
 916         r = sd_dhcp_lease_get_search_domains(lease, &search_domains);
 917         if (r > 0) {
 918                 fputs("DOMAIN_SEARCH_LIST=", f);
 919                 fputstrv(f, search_domains, NULL, NULL);
 920                 fputs("\n", f);
 921         }
 922
 923         r = sd_dhcp_lease_get_hostname(lease, &string);
 924         if (r >= 0)
 925                 fprintf(f, "HOSTNAME=%s\n", string);
 926
 927         r = sd_dhcp_lease_get_root_path(lease, &string);
 928         if (r >= 0)
 929                 fprintf(f, "ROOT_PATH=%s\n", string);
 930
 931         r = sd_dhcp_lease_get_routes(lease, &routes);
 932         if (r > 0)
 933                 serialize_dhcp_routes(f, "ROUTES", routes, r);
 934
 935         r = sd_dhcp_lease_get_timezone(lease, &string);
 936         if (r >= 0)
 937                 fprintf(f, "TIMEZONE=%s\n", string);
 938
 939         r = sd_dhcp_lease_get_client_id(lease, &client_id, &client_id_len);
 940         if (r >= 0) {
 941                 _cleanup_free_ char *client_id_hex = NULL;
 942
 943                 client_id_hex = hexmem(client_id, client_id_len);
 944                 if (!client_id_hex) {
 945                         r = -ENOMEM;
 946                         goto fail;
 947                 }
 948                 fprintf(f, "CLIENTID=%s\n", client_id_hex);
 949         }
 950
 951         r = sd_dhcp_lease_get_vendor_specific(lease, &data, &data_len);
 952         if (r >= 0) {
 953                 _cleanup_free_ char *option_hex = NULL;
 954
 955                 option_hex = hexmem(data, data_len);
 956                 if (!option_hex) {
 957                         r = -ENOMEM;
 958                         goto fail;
 959                 }
 960                 fprintf(f, "VENDOR_SPECIFIC=%s\n", option_hex);
 961         }
 962
 963         LIST_FOREACH(options, option, lease->private_options) {
 964                 char key[STRLEN("OPTION_000")+1];
 965
 966                 xsprintf(key, "OPTION_%" PRIu8, option->tag);
 967                 r = serialize_dhcp_option(f, key, option->data, option->length);
 968                 if (r < 0)
 969                         goto fail;
 970         }
 971
 972         r = fflush_and_check(f);
 973         if (r < 0)
 974                 goto fail;
 975
 976         if (rename(temp_path, lease_file) < 0) {
 977                 r = -errno;
 978                 goto fail;
 979         }
 980
 981         return 0;
 982
 983 fail:
 984         if (temp_path)
 985                 (void) unlink(temp_path);
 986
 987         return log_error_errno(r, "Failed to save lease data %s: %m", lease_file);
 988 }
 989
 990 int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
 991
 992         _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
 993         _cleanup_free_ char
 994                 *address = NULL,
 995                 *router = NULL,
 996                 *netmask = NULL,
 997                 *server_address = NULL,
 998                 *next_server = NULL,
 999                 *broadcast = NULL,
1000                 *dns = NULL,
1001                 *ntp = NULL,
1002                 *mtu = NULL,
1003                 *routes = NULL,
1004                 *domains = NULL,
1005                 *client_id_hex = NULL,
1006                 *vendor_specific_hex = NULL,
1007                 *lifetime = NULL,
1008                 *t1 = NULL,
1009                 *t2 = NULL,
1010                 *options[SD_DHCP_OPTION_PRIVATE_LAST - SD_DHCP_OPTION_PRIVATE_BASE + 1] = {};
1011
1012         int r, i;
1013
1014         assert(lease_file);
1015         assert(ret);
1016
1017         r = dhcp_lease_new(&lease);
1018         if (r < 0)
1019                 return r;
1020
1021         r = parse_env_file(NULL, lease_file,
1022                            "ADDRESS", &address,
1023                            "ROUTER", &router,
1024                            "NETMASK", &netmask,
1025                            "SERVER_IDENTIFIER", &server_address,
1026                            "NEXT_SERVER", &next_server,
1027                            "BROADCAST", &broadcast,
1028                            "DNS", &dns,
1029                            "NTP", &ntp,
1030                            "MTU", &mtu,
1031                            "DOMAINNAME", &lease->domainname,
1032                            "HOSTNAME", &lease->hostname,
1033                            "DOMAIN_SEARCH_LIST", &domains,
1034                            "ROOT_PATH", &lease->root_path,
1035                            "ROUTES", &routes,
1036                            "CLIENTID", &client_id_hex,
1037                            "TIMEZONE", &lease->timezone,
1038                            "VENDOR_SPECIFIC", &vendor_specific_hex,
1039                            "LIFETIME", &lifetime,
1040                            "T1", &t1,
1041                            "T2", &t2,
1042                            "OPTION_224", &options[0],
1043                            "OPTION_225", &options[1],
1044                            "OPTION_226", &options[2],
1045                            "OPTION_227", &options[3],
1046                            "OPTION_228", &options[4],
1047                            "OPTION_229", &options[5],
1048                            "OPTION_230", &options[6],
1049                            "OPTION_231", &options[7],
1050                            "OPTION_232", &options[8],
1051                            "OPTION_233", &options[9],
1052                            "OPTION_234", &options[10],
1053                            "OPTION_235", &options[11],
1054                            "OPTION_236", &options[12],
1055                            "OPTION_237", &options[13],
1056                            "OPTION_238", &options[14],
1057                            "OPTION_239", &options[15],
1058                            "OPTION_240", &options[16],
1059                            "OPTION_241", &options[17],
1060                            "OPTION_242", &options[18],
1061                            "OPTION_243", &options[19],
1062                            "OPTION_244", &options[20],
1063                            "OPTION_245", &options[21],
1064                            "OPTION_246", &options[22],
1065                            "OPTION_247", &options[23],
1066                            "OPTION_248", &options[24],
1067                            "OPTION_249", &options[25],
1068                            "OPTION_250", &options[26],
1069                            "OPTION_251", &options[27],
1070                            "OPTION_252", &options[28],
1071                            "OPTION_253", &options[29],
1072                            "OPTION_254", &options[30]);
1073         if (r < 0)
1074                 return r;
1075
1076         if (address) {
1077                 r = inet_pton(AF_INET, address, &lease->address);
1078                 if (r <= 0)
1079                         log_debug("Failed to parse address %s, ignoring.", address);
1080         }
1081
1082         if (router) {
1083                 r = inet_pton(AF_INET, router, &lease->router);
1084                 if (r <= 0)
1085                         log_debug("Failed to parse router %s, ignoring.", router);
1086         }
1087
1088         if (netmask) {
1089                 r = inet_pton(AF_INET, netmask, &lease->subnet_mask);
1090                 if (r <= 0)
1091                         log_debug("Failed to parse netmask %s, ignoring.", netmask);
1092                 else
1093                         lease->have_subnet_mask = true;
1094         }
1095
1096         if (server_address) {
1097                 r = inet_pton(AF_INET, server_address, &lease->server_address);
1098                 if (r <= 0)
1099                         log_debug("Failed to parse server address %s, ignoring.", server_address);
1100         }
1101
1102         if (next_server) {
1103                 r = inet_pton(AF_INET, next_server, &lease->next_server);
1104                 if (r <= 0)
1105                         log_debug("Failed to parse next server %s, ignoring.", next_server);
1106         }
1107
1108         if (broadcast) {
1109                 r = inet_pton(AF_INET, broadcast, &lease->broadcast);
1110                 if (r <= 0)
1111                         log_debug("Failed to parse broadcast address %s, ignoring.", broadcast);
1112                 else
1113                         lease->have_broadcast = true;
1114         }
1115
1116         if (dns) {
1117                 r = deserialize_in_addrs(&lease->dns, dns);
1118                 if (r < 0)
1119                         log_debug_errno(r, "Failed to deserialize DNS servers %s, ignoring: %m", dns);
1120                 else
1121                         lease->dns_size = r;
1122         }
1123
1124         if (ntp) {
1125                 r = deserialize_in_addrs(&lease->ntp, ntp);
1126                 if (r < 0)
1127                         log_debug_errno(r, "Failed to deserialize NTP servers %s, ignoring: %m", ntp);
1128                 else
1129                         lease->ntp_size = r;
1130         }
1131
1132         if (mtu) {
1133                 r = safe_atou16(mtu, &lease->mtu);
1134                 if (r < 0)
1135                         log_debug_errno(r, "Failed to parse MTU %s, ignoring: %m", mtu);
1136         }
1137
1138         if (domains) {
1139                 _cleanup_strv_free_ char **a = NULL;
1140                 a = strv_split(domains, " ");
1141                 if (!a)
1142                         return -ENOMEM;
1143
1144                 if (!strv_isempty(a)) {
1145                         lease->search_domains = a;
1146                         a = NULL;
1147                 }
1148         }
1149
1150         if (routes) {
1151                 r = deserialize_dhcp_routes(
1152                                 &lease->static_route,
1153                                 &lease->static_route_size,
1154                                 &lease->static_route_allocated,
1155                                 routes);
1156                 if (r < 0)
1157                         log_debug_errno(r, "Failed to parse DHCP routes %s, ignoring: %m", routes);
1158         }
1159
1160         if (lifetime) {
1161                 r = safe_atou32(lifetime, &lease->lifetime);
1162                 if (r < 0)
1163                         log_debug_errno(r, "Failed to parse lifetime %s, ignoring: %m", lifetime);
1164         }
1165
1166         if (t1) {
1167                 r = safe_atou32(t1, &lease->t1);
1168                 if (r < 0)
1169                         log_debug_errno(r, "Failed to parse T1 %s, ignoring: %m", t1);
1170         }
1171
1172         if (t2) {
1173                 r = safe_atou32(t2, &lease->t2);
1174                 if (r < 0)
1175                         log_debug_errno(r, "Failed to parse T2 %s, ignoring: %m", t2);
1176         }
1177
1178         if (client_id_hex) {
1179                 r = unhexmem(client_id_hex, (size_t) -1, &lease->client_id, &lease->client_id_len);
1180                 if (r < 0)
1181                         log_debug_errno(r, "Failed to parse client ID %s, ignoring: %m", client_id_hex);
1182         }
1183
1184         if (vendor_specific_hex) {
1185                 r = unhexmem(vendor_specific_hex, (size_t) -1, &lease->vendor_specific, &lease->vendor_specific_len);
1186                 if (r < 0)
1187                         log_debug_errno(r, "Failed to parse vendor specific data %s, ignoring: %m", vendor_specific_hex);
1188         }
1189
1190         for (i = 0; i <= SD_DHCP_OPTION_PRIVATE_LAST - SD_DHCP_OPTION_PRIVATE_BASE; i++) {
1191                 _cleanup_free_ void *data = NULL;
1192                 size_t len;
1193
1194                 if (!options[i])
1195                         continue;
1196
1197                 r = unhexmem(options[i], (size_t) -1, &data, &len);
1198                 if (r < 0) {
1199                         log_debug_errno(r, "Failed to parse private DHCP option %s, ignoring: %m", options[i]);
1200                         continue;
1201                 }
1202
1203                 r = dhcp_lease_insert_private_option(lease, SD_DHCP_OPTION_PRIVATE_BASE + i, data, len);
1204                 if (r < 0)
1205                         return r;
1206         }
1207
1208         *ret = TAKE_PTR(lease);
1209
1210         return 0;
1211 }
1212
1213 int dhcp_lease_set_default_subnet_mask(sd_dhcp_lease *lease) {
1214         struct in_addr address, mask;
1215         int r;
1216
1217         assert(lease);
1218
1219         if (lease->address == 0)
1220                 return -ENODATA;
1221
1222         address.s_addr = lease->address;
1223
1224         /* fall back to the default subnet masks based on address class */
1225         r = in4_addr_default_subnet_mask(&address, &mask);
1226         if (r < 0)
1227                 return r;
1228
1229         lease->subnet_mask = mask.s_addr;
1230         lease->have_subnet_mask = true;
1231
1232         return 0;
1233 }
1234
1235 int sd_dhcp_lease_get_client_id(sd_dhcp_lease *lease, const void **client_id, size_t *client_id_len) {
1236         assert_return(lease, -EINVAL);
1237         assert_return(client_id, -EINVAL);
1238         assert_return(client_id_len, -EINVAL);
1239
1240         if (!lease->client_id)
1241                 return -ENODATA;
1242
1243         *client_id = lease->client_id;
1244         *client_id_len = lease->client_id_len;
1245
1246         return 0;
1247 }
1248
1249 int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const void *client_id, size_t client_id_len) {
1250         assert_return(lease, -EINVAL);
1251         assert_return(client_id || client_id_len <= 0, -EINVAL);
1252
1253         if (client_id_len <= 0)
1254                 lease->client_id = mfree(lease->client_id);
1255         else {
1256                 void *p;
1257
1258                 p = memdup(client_id, client_id_len);
1259                 if (!p)
1260                         return -ENOMEM;
1261
1262                 free(lease->client_id);
1263                 lease->client_id = p;
1264                 lease->client_id_len = client_id_len;
1265         }
1266
1267         return 0;
1268 }
1269
1270 int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **tz) {
1271         assert_return(lease, -EINVAL);
1272         assert_return(tz, -EINVAL);
1273
1274         if (!lease->timezone)
1275                 return -ENODATA;
1276
1277         *tz = lease->timezone;
1278         return 0;
1279 }
1280
1281 int sd_dhcp_route_get_destination(sd_dhcp_route *route, struct in_addr *destination) {
1282         assert_return(route, -EINVAL);
1283         assert_return(destination, -EINVAL);
1284
1285         *destination = route->dst_addr;
1286         return 0;
1287 }
1288
1289 int sd_dhcp_route_get_destination_prefix_length(sd_dhcp_route *route, uint8_t *length) {
1290         assert_return(route, -EINVAL);
1291         assert_return(length, -EINVAL);
1292
1293         *length = route->dst_prefixlen;
1294         return 0;
1295 }
1296
1297 int sd_dhcp_route_get_gateway(sd_dhcp_route *route, struct in_addr *gateway) {
1298         assert_return(route, -EINVAL);
1299         assert_return(gateway, -EINVAL);
1300
1301         *gateway = route->gw_addr;
1302         return 0;
1303 }
1304
1305 int sd_dhcp_route_get_option(sd_dhcp_route *route) {
1306         assert_return(route, -EINVAL);
1307
1308         return route->option;
1309 }