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